public void Expect__テスト対象クラスとテストメソッドを引数指定したExpectは指定されたメソッドを実行する_引数1個の場合()
 {
     // setup
     save1 = false;
     // when
     FixtureBook.Expect(typeof(Wrapper), "Save", typeof(List <Employee>));
     // then
     Assert.IsTrue(save1);
 }
 public void ValidateParameter__ValidateParameterAtメソッドのインデックスがExpectの引数の数よりも多い場合は例外が発生する()
 {
     // expect
     new FixtureBook().Validate <ConfigException>(() =>
                                                  FixtureBook.Expect((FixtureBookAttributeTestData a, FixtureBookAttributeTestData b) => { }
                                                                     ).ValidateParameterAt(2));
     new FixtureBook().Validate <ConfigException>(() =>
                                                  FixtureBook.Expect((FixtureBookAttributeTestData a) => { }
                                                                     ).ValidateParameterAt(2, "xxx"));
 }
        public void Expectは指定されたラムダ式の実行ができる()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect(() => called = true);

            // then
            Assert.IsTrue(called);
        }
        public void Expect__引数なしの場合は全くテーブル定義がなくてもなんとなく動作する()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect(() => called = true);

            // then
            Assert.IsTrue(called);
        }
 public void 数値項目が読み込めること()
 {
     FixtureBook.Expect((List <Data> list) =>
     {
         Assert.AreEqual(4, list.Count);
         Assert.AreEqual((decimal)1000.00, list[0].Decimal1);
         Assert.AreEqual((decimal)1000.01, list[1].Decimal1);
         Assert.AreEqual((decimal)1000.02, list[2].Decimal1);
         Assert.AreEqual((decimal)1000.03, list[3].Decimal1);
     });
 }
 public void Boolean項目が読み込めること()
 {
     FixtureBook.Expect((List <Data> list) =>
     {
         Assert.AreEqual(4, list.Count);
         Assert.IsTrue(list[0].Bool1);
         Assert.IsFalse(list[1].Bool1);
         Assert.IsFalse(list[2].Bool1);
         Assert.IsTrue(list[3].Bool1);
     });
 }
        public void Expect__配列も取得できる()
        {
            // setup
            FixtureBookAttributeTestData[] data = null;

            // when
            FixtureBook.Expect((FixtureBookAttributeTestData[] p1) => data = p1);

            // then
            Assert.AreEqual(2, data.Length);
            Assert.AreEqual("abc", data[0].Text);
            Assert.AreEqual("efg", data[1].Text);
        }
        public void Expect__DataSetを引数にした場合Dパラメタにあるすべてのテーブル定義を取得する()
        {
            FixtureBook.Expect <DataTable, DataSet>((dataTable, dataSet) =>
            {
                Assert.AreEqual(2, dataSet.Tables.Count);
                Assert.AreEqual("abc", dataSet.Tables[0].Rows[0]["text"]);
                Assert.AreEqual("abc", dataSet.Tables["Data1"].Rows[0]["text"]);
                Assert.AreEqual("def", dataSet.Tables[1].Rows[0]["text"]);
                Assert.AreEqual("def", dataSet.Tables["Data2"].Rows[0]["text"]);

                Assert.AreEqual("abc", dataTable.Rows[0]["text"]);
            });
        }
        public void Expect__リストデータも取得できる()
        {
            // setup
            List <FixtureBookAttributeTestData> data = null;

            // when
            FixtureBook.Expect((List <FixtureBookAttributeTestData> p1) => data = p1);

            // then
            Assert.AreEqual(2, data.Count);
            Assert.AreEqual("abc", data[0].Text);
            Assert.AreEqual("efg", data[1].Text);
        }
 public void 日時項目が読み込めること()
 {
     FixtureBook.Expect((List <Data> list) =>
     {
         Assert.AreEqual(6, list.Count);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 1), list[0].DateTime1);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 2), list[1].DateTime1);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 3), list[2].DateTime1);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 4), list[3].DateTime1);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 5), list[4].DateTime1);
         Assert.AreEqual(new DateTime(2013, 12, 11, 0, 1, 6), list[5].DateTime1);
     });
 }
 public void Expect__指定されたメソッドがみつからない場合は例外をスローする_メソッド引数指定なしの場合()
 {
     try
     {
         // when
         FixtureBook.Expect(typeof(Wrapper), "xxxx");
     }
     catch (ConfigException e)
     {
         // then
         Console.WriteLine(e);
         Assert.AreEqual("M_Fixture_Temp_Conductor_CannotFindMethod", e.ResourceKey);
     }
 }
 public void Expect__引数があるのにDパラメタにテーブル定義がないとエラーになる()
 {
     try
     {
         FixtureBook.Expect((FixtureBookTestData data) => { });
         Assert.Fail("ここにはこない");
     }
     catch (ConfigException e)
     {
         Console.WriteLine(e.Message);
         Console.WriteLine(e.ResourceKey);
         Assert.AreEqual("M_Fixture_FixtureBook_GetTable_ObjectForExec", e.ResourceKey);
     }
 }
Exemple #13
0
 public void Xxxx__引数なしのExpectは類推したテスト対象メソッドが存在しない場合は例外をスローする()
 {
     try
     {
         // when
         FixtureBook.Expect();
         Assert.Fail("ここにはこない");
     }
     catch (ConfigException e)
     {
         // then
         Console.WriteLine(e);
         Assert.AreEqual("M_Fixture_FixtureBook_GetDefaultTargetMethod", e.ResourceKey);
     }
 }
 public void Expect__指定されたクラスのインスタンスが作成できない場合は例外をスローする()
 {
     try
     {
         // when
         FixtureBook.Expect(typeof(Uncreatable), "Save", typeof(List <Employee>));
         Assert.Fail("ここにはこない");
     }
     catch (ConfigException e)
     {
         // then
         Console.WriteLine(e);
         Assert.AreEqual("M_Fixture_Temp_Conductor_CannotCreateInstance", e.ResourceKey);
     }
 }
        public void Expect1はDパラメタに定義されたオブジェクトを1つの引数として取得ができる()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect((FixtureBookTestData p1) =>
            {
                called = true;
                Assert.AreEqual("abc", p1.Text);
            });

            // then
            Assert.IsTrue(called);
        }
 public void 引数なしのexpectはテストクラス名が命名規約に沿っていない場合は例外をスローする()
 {
     try
     {
         // when
         FixtureBook.Expect();
         Assert.Fail("ここにはこない");
     }
     catch (ConfigException e)
     {
         // then
         Console.WriteLine(e);
         Assert.AreEqual("M_Fixture_FixtureBook_GetDefaultTargetClassName", e.ResourceKey);
     }
 }
        public void Expectは引数なしの場合Setupとテスト対象メソッド呼び出しとValidateStorageができる_正常終了()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect(() =>
            {
                ValidateDatabase(111);
                called = true;
            });

            // then
            Assert.IsTrue(called);
        }
        public void Expect__引数がある場合はDパラメタの定義だけで正常動作する()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect((FixtureBookTestData data) =>
            {
                Assert.AreEqual("abc", data.Text);
                called = true;
            });

            // then
            Assert.IsTrue(called);
        }
 public void Expect__引数がある場合にGetObjectとテスト対象メソッド呼び出しとValidateStorageができる_ValidateStorageエラー()
 {
     try
     {
         // when
         FixtureBook.Expect((FixtureBookTestData data) => UpdateDatabase(113));
         throw new Exception("ここにはこない");
     }
     catch (AssertFailedException e)
     {
         //then
         Console.WriteLine(e.Message);
         Assert.IsTrue(e.Message.IndexOf("<112>") > -1);
         Assert.IsTrue(e.Message.IndexOf("<113>") > -1);
     }
 }
        public void Expect__引数がある場合にGetObjectとテスト対象メソッド呼び出しとValidateStorageができる_正常終了()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect((FixtureBookTestData data) =>
            {
                Assert.AreEqual("abc", data.Text);
                ValidateDatabase(112);
                called = true;
            });

            //then
            Assert.IsTrue(called);
        }
        public void Expect4はDパラメタに定義されたオブジェクトを4つの引数として取得ができる()
        {
            // setup
            bool called = false;

            // when
            FixtureBook.Expect((FixtureBookTestData p1, FixtureBookTestData p2,
                                FixtureBookTestData p3, FixtureBookTestData p4) =>
            {
                called = true;
                Assert.AreEqual("abc", p1.Text);
                Assert.AreEqual("def", p2.Text);
                Assert.AreEqual("ghi", p3.Text);
                Assert.AreEqual("jkl", p4.Text);
            });

            // then
            Assert.IsTrue(called);
        }
        public void intを作成できる()
        {
            {
                // when
                int obj = fixtureBook.GetObject <int>();
                // then
                Assert.AreEqual(1, obj);
            }

            {
                // when
                List <int> list = fixtureBook.GetList <int>();
                // then
                Assert.AreEqual(2, list.Count);
                Assert.AreEqual(1, list[0]);
                Assert.AreEqual(2, list[1]);
            }

            {
                // when
                int[] array = fixtureBook.GetArray <int>();
                // then
                Assert.AreEqual(2, array.Length);
                Assert.AreEqual(1, array[0]);
                Assert.AreEqual(2, array[1]);
            }

            // expect
            FixtureBook.Expect((int obj) => Assert.AreEqual(1, obj));
            FixtureBook.Expect((List <int> list) =>
            {
                Assert.AreEqual(2, list.Count);
                Assert.AreEqual(1, list[0]);
                Assert.AreEqual(2, list[1]);
            });
            FixtureBook.Expect((int[] array) =>
            {
                Assert.AreEqual(2, array.Length);
                Assert.AreEqual(1, array[0]);
                Assert.AreEqual(2, array[1]);
            });
        }
 public void Expectは引数なしの場合Setupとテスト対象メソッド呼び出しとValidateStorageができる_エラー()
 {
     try
     {
         // when
         FixtureBook.Expect(() =>
         {
             ValidateDatabase(111);
             UpdateDatabase(112);
         });
         throw new Exception("ここにはこない");
     }
     catch (AssertFailedException e)
     {
         //then
         Console.WriteLine(e.Message);
         Assert.IsTrue(e.Message.IndexOf("<111>") > -1);
         Assert.IsTrue(e.Message.IndexOf("<112>") > -1);
     }
 }
        public void stringを作成できる()
        {
            // when
            string obj = fixtureBook.GetObject <String>();

            // then
            Assert.AreEqual("a", obj);

            {
                // when
                List <string> list = fixtureBook.GetList <string>();
                // then
                Assert.AreEqual(2, list.Count);
                Assert.AreEqual("a", list[0]);
                Assert.AreEqual("b", list[1]);
            }

            {
                // when
                string[] array = fixtureBook.GetArray <string>();
                // then
                Assert.AreEqual(2, array.Length);
                Assert.AreEqual("a", array[0]);
                Assert.AreEqual("b", array[1]);
            }

            // expect
            FixtureBook.Expect((string s) => Assert.AreEqual("a", s));
            FixtureBook.Expect((List <string> list) =>
            {
                Assert.AreEqual(2, list.Count);
                Assert.AreEqual("a", list[0]);
                Assert.AreEqual("b", list[1]);
            });
            FixtureBook.Expect((string[] array) =>
            {
                Assert.AreEqual(2, array.Length);
                Assert.AreEqual("a", array[0]);
                Assert.AreEqual("b", array[1]);
            });
        }
        public void ValidateParameterAtは指定したインデックスの引数を検証する()
        {
            // setup
            FixtureBook fixtureBook = FixtureBook.Expect((FixtureBookTestData p1, FixtureBookTestData p2,
                                                          FixtureBookTestData p3, FixtureBookTestData p4) => {});

            // expect : normal
            fixtureBook.ValidateParameterAt(0);
            fixtureBook.ValidateParameterAt(1, 2, 3);


            fixtureBook.ValidateParameterAt(0, "Parameter1");
            fixtureBook.ValidateParameterAt(1, "Parameter2").
            ValidateParameterAt(2, "Parameter3").
            ValidateParameterAt(3, "Parameter4");

            // expect : error
            try
            {
                fixtureBook.ValidateParameterAt(0, "Parameter2");
            }
            catch (AssertFailedException e)
            {
                Console.WriteLine(e.Message);
                Assert.IsTrue(e.Message.IndexOf("<abc>") > -1);
                Assert.IsTrue(e.Message.IndexOf("<def>") > -1);
            }

            // expect : error
            try
            {
                fixtureBook.ValidateParameterAt(0, "xxx");
            }
            catch (ConfigException e)
            {
                Console.WriteLine(e.Message);
                Assert.IsTrue(e.Message.IndexOf("xxx") > -1);
            }
        }
        public void GetParameterAtは指定したインデックスの引数を取得する()
        {
            // setup
            FixtureBookTestData[] data        = new FixtureBookTestData[4];
            FixtureBook           fixtureBook = FixtureBook.Expect((FixtureBookTestData p1, FixtureBookTestData p2,
                                                                    FixtureBookTestData p3, FixtureBookTestData p4) =>
            {
                data[0] = p1;
                data[1] = p2;
                data[2] = p3;
                data[3] = p4;
            });

            // expect
            Assert.AreSame(data[0], fixtureBook.GetParameterAt <FixtureBookTestData>(0));
            Assert.AreSame(data[1], fixtureBook.GetParameterAt <FixtureBookTestData>(1));
            Assert.AreSame(data[2], fixtureBook.GetParameterAt <FixtureBookTestData>(2));
            Assert.AreSame(data[3], fixtureBook.GetParameterAt <FixtureBookTestData>(3));
            Assert.AreEqual("abc", fixtureBook.GetParameterAt <FixtureBookTestData>(0).Text);
            Assert.AreEqual("def", fixtureBook.GetParameterAt <FixtureBookTestData>(1).Text);
            Assert.AreEqual("ghi", fixtureBook.GetParameterAt <FixtureBookTestData>(2).Text);
            Assert.AreEqual("jkl", fixtureBook.GetParameterAt <FixtureBookTestData>(3).Text);
        }
Exemple #27
0
 public void Delete__指定した従業員データのIDをキーにしてデータベーステーブルEMPLOYEE上のデータが削除される()
 {
     FixtureBook.Expect();
 }
Exemple #28
0
 public void Save__データベーステーブルEMPLOYEEに従業員データを新規追加できる()
 {
     FixtureBook.Expect();
 }
 public void ValidateParameter__GetParameterAtメソッドのインデックスがExpectの引数の数よりも多い場合は例外が発生する()
 {
     // expect
     new FixtureBook().Validate <ConfigException>(() => FixtureBook.Expect(() => { }).GetParameterAt <string>(0));
 }
Exemple #30
0
 public void Save__引数なしのExpectはテストクラス名とテストカテゴリからテスト対象メソッドを類推して実行する()
 {
     FixtureBook.Expect();
 }