mcs/class/System.Data/Test/System.Data.Odbc/OdbcCommandTest.cs

   1 //
   2 // OdbcCommandTest.cs - NUnit Test Cases for testing
   3 // System.Data.Odbc.OdbcCommand
   4 //
   5 // Author:
   6 //      Gert Driesen (drieseng@users.sourceforge.net)
   7 //
   8 // Copyright (c) 2007 Gert Driesen
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Data;
  32 using System.Data.Odbc;
  33
  34 using NUnit.Framework;
  35
  36 namespace MonoTests.System.Data.Odbc
  37 {
  38         [TestFixture]
  39         public class OdbcCommandTest
  40         {
  41                 const string COMMAND_TEXT = "SELECT * FROM Authors";
  42
  43                 [Test] // OdbcCommand ()
  44                 public void Constructor1 ()
  45                 {
  46                         OdbcCommand cmd = new OdbcCommand ();
  47                         Assert.AreEqual (string.Empty, cmd.CommandText, "#1");
  48                         Assert.AreEqual (30, cmd.CommandTimeout, "#2");
  49                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#3");
  50                         Assert.IsNull (cmd.Connection, "#4");
  51                         Assert.IsNull (cmd.Container, "#5");
  52                         Assert.IsTrue (cmd.DesignTimeVisible, "#6");
  53                         Assert.IsNotNull (cmd.Parameters, "#7");
  54                         Assert.AreEqual (0, cmd.Parameters.Count, "#8");
  55                         Assert.IsNull (cmd.Site, "#9");
  56                         Assert.IsNull (cmd.Transaction, "#10");
  57                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#11");
  58                 }
  59
  60                 [Test] // OdbcCommand (String)
  61                 public void Constructor2 ()
  62                 {
  63                         OdbcCommand cmd = new OdbcCommand (COMMAND_TEXT);
  64                         Assert.AreEqual (COMMAND_TEXT, cmd.CommandText, "#A1");
  65                         Assert.AreEqual (30, cmd.CommandTimeout, "#A2");
  66                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#A3");
  67                         Assert.IsNull (cmd.Connection, "#A4");
  68                         Assert.IsNull (cmd.Container, "#A5");
  69                         Assert.IsTrue (cmd.DesignTimeVisible, "#A6");
  70                         Assert.IsNotNull (cmd.Parameters, "#A7");
  71                         Assert.AreEqual (0, cmd.Parameters.Count, "#A8");
  72                         Assert.IsNull (cmd.Site, "#A9");
  73                         Assert.IsNull (cmd.Transaction, "#A10");
  74                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#A11");
  75
  76                         cmd = new OdbcCommand ((string) null);
  77                         Assert.AreEqual (string.Empty, cmd.CommandText, "#B1");
  78                         Assert.AreEqual (30, cmd.CommandTimeout, "#B2");
  79                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#B3");
  80                         Assert.IsNull (cmd.Connection, "#B4");
  81                         Assert.IsNull (cmd.Container, "#B5");
  82                         Assert.IsTrue (cmd.DesignTimeVisible, "#B6");
  83                         Assert.IsNotNull (cmd.Parameters, "#B7");
  84                         Assert.AreEqual (0, cmd.Parameters.Count, "#B8");
  85                         Assert.IsNull (cmd.Site, "#B9");
  86                         Assert.IsNull (cmd.Transaction, "#B10");
  87                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#B11");
  88                 }
  89
  90                 [Test] // OdbcCommand (String, OdbcConnection)
  91                 public void Constructor3 ()
  92                 {
  93                         OdbcConnection conn = new OdbcConnection ();
  94                         OdbcCommand cmd;
  95
  96                         cmd = new OdbcCommand (COMMAND_TEXT, conn);
  97                         Assert.AreEqual (COMMAND_TEXT, cmd.CommandText, "#A1");
  98                         Assert.AreEqual (30, cmd.CommandTimeout, "#A2");
  99                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#A3");
 100                         Assert.AreSame (conn, cmd.Connection, "#A4");
 101                         Assert.IsNull (cmd.Container, "#A5");
 102                         Assert.IsTrue (cmd.DesignTimeVisible, "#A6");
 103                         Assert.IsNotNull (cmd.Parameters, "#A7");
 104                         Assert.AreEqual (0, cmd.Parameters.Count, "#A8");
 105                         Assert.IsNull (cmd.Site, "#A9");
 106                         Assert.IsNull (cmd.Transaction, "#A10");
 107                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#A11");
 108
 109                         cmd = new OdbcCommand ((string) null, conn);
 110                         Assert.AreEqual (string.Empty, cmd.CommandText, "#B1");
 111                         Assert.AreEqual (30, cmd.CommandTimeout, "#B2");
 112                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#B3");
 113                         Assert.AreSame (conn, cmd.Connection, "#B4");
 114                         Assert.IsNull (cmd.Container, "#B5");
 115                         Assert.IsTrue (cmd.DesignTimeVisible, "#B6");
 116                         Assert.IsNotNull (cmd.Parameters, "#B7");
 117                         Assert.AreEqual (0, cmd.Parameters.Count, "#B8");
 118                         Assert.IsNull (cmd.Site, "#B9");
 119                         Assert.IsNull (cmd.Transaction, "#B10");
 120                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#B11");
 121
 122                         cmd = new OdbcCommand (COMMAND_TEXT, (OdbcConnection) null);
 123                         Assert.AreEqual (COMMAND_TEXT, cmd.CommandText, "#C1");
 124                         Assert.AreEqual (30, cmd.CommandTimeout, "#C2");
 125                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#C3");
 126                         Assert.IsNull (cmd.Connection, "#C4");
 127                         Assert.IsNull (cmd.Container, "#C5");
 128                         Assert.IsTrue (cmd.DesignTimeVisible, "#C6");
 129                         Assert.IsNotNull (cmd.Parameters, "#C7");
 130                         Assert.AreEqual (0, cmd.Parameters.Count, "#C8");
 131                         Assert.IsNull (cmd.Site, "#C9");
 132                         Assert.IsNull (cmd.Transaction, "#C10");
 133                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#C11");
 134                 }
 135
 136                 [Test] // OdbcCommand (String, OdbcConnection, OdbcTransaction)
 137                 public void Constructor4 ()
 138                 {
 139                         OdbcConnection conn = new OdbcConnection ();
 140                         OdbcCommand cmd;
 141
 142                         cmd = new OdbcCommand (COMMAND_TEXT, conn, (OdbcTransaction) null);
 143                         Assert.AreEqual (COMMAND_TEXT, cmd.CommandText, "#A1");
 144                         Assert.AreEqual (30, cmd.CommandTimeout, "#A2");
 145                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#A3");
 146                         Assert.AreSame (conn, cmd.Connection, "#A4");
 147                         Assert.IsNull (cmd.Container, "#A5");
 148                         Assert.IsTrue (cmd.DesignTimeVisible, "#A6");
 149                         Assert.IsNotNull (cmd.Parameters, "#A7");
 150                         Assert.AreEqual (0, cmd.Parameters.Count, "#A8");
 151                         Assert.IsNull (cmd.Site, "#A9");
 152                         Assert.IsNull (cmd.Transaction, "#A10");
 153                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#A11");
 154
 155                         cmd = new OdbcCommand ((string) null, conn, (OdbcTransaction) null);
 156                         Assert.AreEqual (string.Empty, cmd.CommandText, "#B1");
 157                         Assert.AreEqual (30, cmd.CommandTimeout, "#B2");
 158                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#B3");
 159                         Assert.AreSame (conn, cmd.Connection, "#B4");
 160                         Assert.IsNull (cmd.Container, "#B5");
 161                         Assert.IsTrue (cmd.DesignTimeVisible, "#B6");
 162                         Assert.IsNotNull (cmd.Parameters, "#B7");
 163                         Assert.AreEqual (0, cmd.Parameters.Count, "#B8");
 164                         Assert.IsNull (cmd.Site, "#B9");
 165                         Assert.IsNull (cmd.Transaction, "#B10");
 166                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#B11");
 167
 168                         cmd = new OdbcCommand (COMMAND_TEXT, (OdbcConnection) null, (OdbcTransaction) null);
 169                         Assert.AreEqual (COMMAND_TEXT, cmd.CommandText, "#C1");
 170                         Assert.AreEqual (30, cmd.CommandTimeout, "#C2");
 171                         Assert.AreEqual (CommandType.Text, cmd.CommandType, "#C3");
 172                         Assert.IsNull (cmd.Connection, "#C4");
 173                         Assert.IsNull (cmd.Container, "#C5");
 174                         Assert.IsTrue (cmd.DesignTimeVisible, "#C6");
 175                         Assert.IsNotNull (cmd.Parameters, "#C7");
 176                         Assert.AreEqual (0, cmd.Parameters.Count, "#C8");
 177                         Assert.IsNull (cmd.Site, "#C9");
 178                         Assert.IsNull (cmd.Transaction, "#C10");
 179                         Assert.AreEqual (UpdateRowSource.Both, cmd.UpdatedRowSource, "#C11");
 180                 }
 181
 182                 [Test]
 183                 public void CommandText ()
 184                 {
 185                         OdbcCommand cmd = new OdbcCommand ();
 186                         cmd.CommandText = COMMAND_TEXT;
 187                         Assert.AreSame (COMMAND_TEXT, cmd.CommandText, "#1");
 188                         cmd.CommandText = null;
 189                         Assert.AreEqual (string.Empty, cmd.CommandText, "#2");
 190                         cmd.CommandText = COMMAND_TEXT;
 191                         Assert.AreSame (COMMAND_TEXT, cmd.CommandText, "#3");
 192                         cmd.CommandText = string.Empty;
 193                         Assert.AreEqual (string.Empty, cmd.CommandText, "#4");
 194                 }
 195
 196                 [Test]
 197                 public void CommandTimeout ()
 198                 {
 199                         OdbcCommand cmd = new OdbcCommand ();
 200                         cmd.CommandTimeout = 10;
 201                         Assert.AreEqual (10, cmd.CommandTimeout, "#1");
 202                         cmd.CommandTimeout = 25;
 203                         Assert.AreEqual (25, cmd.CommandTimeout, "#2");
 204                         cmd.CommandTimeout = 0;
 205                         Assert.AreEqual (0, cmd.CommandTimeout, "#3");
 206                 }
 207
 208                 [Test]
 209                 public void CommandTimeout_Value_Negative ()
 210                 {
 211                         OdbcCommand cmd = new OdbcCommand ();
 212                         try {
 213                                 cmd.CommandTimeout = -1;
 214                                 Assert.Fail ("#1");
 215                         } catch (ArgumentException ex) {
 216                                 // Invalid CommandTimeout value -1; the value must be >= 0
 217                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 218                                 Assert.IsNull (ex.InnerException, "#3");
 219                                 Assert.IsNotNull (ex.Message, "#4");
 220                                 Assert.AreEqual ("CommandTimeout", ex.ParamName, "#5");
 221                         }
 222                 }
 223
 224                 [Test]
 225                 public void CommandType_Value_Invalid ()
 226                 {
 227                         OdbcCommand cmd = new OdbcCommand ();
 228                         try {
 229                                 cmd.CommandType = (CommandType) (666);
 230                                 Assert.Fail ("#1");
 231                         } catch (ArgumentOutOfRangeException ex) {
 232                                 // The CommandType enumeration value, 666, is invalid
 233                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 234                                 Assert.IsNull (ex.InnerException, "#3");
 235                                 Assert.IsNotNull (ex.Message, "#4");
 236                                 Assert.IsTrue (ex.Message.IndexOf ("666") != -1, "#5:" + ex.Message);
 237                                 Assert.AreEqual ("CommandType", ex.ParamName, "#6");
 238                         }
 239                 }
 240
 241                 [Test]
 242                 public void Dispose ()
 243                 {
 244                         OdbcConnection conn = new OdbcConnection ();
 245                         OdbcCommand cmd = null;
 246
 247                         try {
 248                                 cmd = conn.CreateCommand ();
 249                                 cmd.CommandText = "SELECT 'a'";
 250                                 cmd.CommandTimeout = 67;
 251                                 cmd.CommandType = CommandType.StoredProcedure;
 252                                 cmd.DesignTimeVisible = false;
 253                                 cmd.Parameters.Add (new OdbcParameter ());
 254                                 cmd.UpdatedRowSource = UpdateRowSource.OutputParameters;
 255
 256                                 cmd.Dispose ();
 257
 258                                 Assert.AreEqual (string.Empty, cmd.CommandText, "CommandText");
 259                                 Assert.AreEqual (67, cmd.CommandTimeout, "CommandTimeout");
 260                                 Assert.AreEqual (CommandType.StoredProcedure, cmd.CommandType, "CommandType");
 261                                 Assert.IsNull (cmd.Connection, "Connection");
 262                                 Assert.IsFalse (cmd.DesignTimeVisible, "DesignTimeVisible");
 263                                 Assert.IsNotNull (cmd.Parameters, "Parameters#1");
 264                                 Assert.AreEqual (0, cmd.Parameters.Count, "Parameters#2");
 265                                 Assert.IsNull (cmd.Transaction, "Transaction");
 266                                 Assert.AreEqual (UpdateRowSource.OutputParameters, cmd.UpdatedRowSource, "UpdatedRowSource");
 267                         } finally {
 268                                 if (cmd != null)
 269                                         cmd.Dispose ();
 270                                 conn.Dispose ();
 271                         }
 272                 }
 273
 274                 [Test]
 275                 public void ExecuteNonQuery_Connection_Closed ()
 276                 {
 277                         OdbcConnection cn = new OdbcConnection ();
 278                         OdbcCommand cmd = new OdbcCommand (COMMAND_TEXT, cn);
 279                         try {
 280                                 cmd.ExecuteNonQuery ();
 281                                 Assert.Fail ("#1");
 282                         } catch (InvalidOperationException ex) {
 283                                 // ExecuteNonQuery requires an open and available
 284                                 // Connection. The connection's current state is
 285                                 // closed.
 286                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 287                                 Assert.IsNull (ex.InnerException, "#3");
 288                                 Assert.IsNotNull (ex.Message, "#4");
 289                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteNonQuery") != -1, "#5:" + ex.Message);
 290                         }
 291                 }
 292
 293                 [Test]
 294                 public void ExecuteNonQuery_Connection_Null ()
 295                 {
 296                         OdbcCommand cmd = new OdbcCommand ();
 297                         cmd.CommandText = COMMAND_TEXT;
 298
 299                         try {
 300                                 cmd.ExecuteNonQuery ();
 301                                 Assert.Fail ("#1");
 302                         } catch (InvalidOperationException ex) {
 303                                 // ExecuteNonQuery: Connection property
 304                                 // has not been initialized
 305                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 306                                 Assert.IsNull (ex.InnerException, "#3");
 307                                 Assert.IsNotNull (ex.Message, "#4");
 308                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteNonQuery") != -1, "#5:" + ex.Message);
 309                         }
 310                 }
 311
 312                 [Test]
 313                 public void ExecuteReader_Connection_Closed ()
 314                 {
 315                         OdbcConnection cn = new OdbcConnection ();
 316                         OdbcCommand cmd = new OdbcCommand (COMMAND_TEXT, cn);
 317                         try {
 318                                 cmd.ExecuteReader ();
 319                                 Assert.Fail ("#1");
 320                         } catch (InvalidOperationException ex) {
 321                                 // ExecuteNonQuery requires an open and available
 322                                 // Connection. The connection's current state is
 323                                 // closed.
 324                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 325                                 Assert.IsNull (ex.InnerException, "#3");
 326                                 Assert.IsNotNull (ex.Message, "#4");
 327                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteReader") != -1, "#5:" + ex.Message);
 328                         }
 329                 }
 330
 331                 [Test]
 332                 public void ExecuteReader_Connection_Null ()
 333                 {
 334                         OdbcCommand cmd = new OdbcCommand ();
 335                         cmd.CommandText = COMMAND_TEXT;
 336
 337                         try {
 338                                 cmd.ExecuteReader ();
 339                                 Assert.Fail ("#1");
 340                         } catch (InvalidOperationException ex) {
 341                                 // ExecuteNonQuery: Connection property
 342                                 // has not been initialized
 343                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 344                                 Assert.IsNull (ex.InnerException, "#3");
 345                                 Assert.IsNotNull (ex.Message, "#4");
 346                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteReader") != -1, "#5:" + ex.Message);
 347                         }
 348                 }
 349
 350                 [Test]
 351                 public void ExecuteScalar_Connection_Closed ()
 352                 {
 353                         OdbcConnection cn = new OdbcConnection ();
 354                         OdbcCommand cmd = new OdbcCommand (COMMAND_TEXT, cn);
 355                         try {
 356                                 cmd.ExecuteScalar ();
 357                                 Assert.Fail ("#1");
 358                         } catch (InvalidOperationException ex) {
 359                                 // ExecuteNonQuery requires an open and available
 360                                 // Connection. The connection's current state is
 361                                 // closed.
 362                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 363                                 Assert.IsNull (ex.InnerException, "#3");
 364                                 Assert.IsNotNull (ex.Message, "#4");
 365                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteScalar") != -1, "#5:" + ex.Message);
 366                         }
 367                 }
 368
 369                 [Test]
 370                 public void ExecuteScalar_Connection_Null ()
 371                 {
 372                         OdbcCommand cmd = new OdbcCommand ();
 373                         cmd.CommandText = COMMAND_TEXT;
 374
 375                         try {
 376                                 cmd.ExecuteScalar ();
 377                                 Assert.Fail ("#1");
 378                         } catch (InvalidOperationException ex) {
 379                                 // ExecuteNonQuery: Connection property
 380                                 // has not been initialized
 381                                 Assert.AreEqual (typeof (InvalidOperationException), ex.GetType (), "#2");
 382                                 Assert.IsNull (ex.InnerException, "#3");
 383                                 Assert.IsNotNull (ex.Message, "#4");
 384                                 Assert.IsTrue (ex.Message.IndexOf ("ExecuteScalar") != -1, "#5:" + ex.Message);
 385                         }
 386                 }
 387
 388                 [Test]
 389                 public void ResetCommandTimeout ()
 390                 {
 391                         OdbcCommand cmd = new OdbcCommand ();
 392                         cmd.CommandTimeout = 50;
 393                         Assert.AreEqual (cmd.CommandTimeout, 50, "#1");
 394                         cmd.ResetCommandTimeout ();
 395                         Assert.AreEqual (cmd.CommandTimeout, 30, "#2");
 396                 }
 397
 398                 [Test]
 399                 public void UpdatedRowSource ()
 400                 {
 401                         OdbcCommand cmd = new OdbcCommand ();
 402                         cmd.UpdatedRowSource = UpdateRowSource.None;
 403                         Assert.AreEqual (UpdateRowSource.None, cmd.UpdatedRowSource, "#1");
 404                         cmd.UpdatedRowSource = UpdateRowSource.OutputParameters;
 405                         Assert.AreEqual (UpdateRowSource.OutputParameters, cmd.UpdatedRowSource, "#2");
 406                 }
 407
 408                 [Test]
 409                 public void UpdatedRowSource_Value_Invalid ()
 410                 {
 411                         OdbcCommand cmd = new OdbcCommand ();
 412                         try {
 413                                 cmd.UpdatedRowSource = (UpdateRowSource) 666;
 414                                 Assert.Fail ("#1");
 415                         } catch (ArgumentOutOfRangeException ex) {
 416                                 // The UpdateRowSource enumeration value,666,
 417                                 // is invalid
 418                                 Assert.AreEqual (typeof (ArgumentOutOfRangeException), ex.GetType (), "#2");
 419                                 Assert.IsNull (ex.InnerException, "#3");
 420                                 Assert.IsNotNull (ex.Message, "#4");
 421                                 Assert.AreEqual ("UpdateRowSource", ex.ParamName, "#5");
 422                         }
 423                 }
 424         }
 425 }