예제 #1
0
        private async Task CheckConfigdirectoryAsync(string directory)
        {
            Assert.True(Directory.Exists(directory), $"Directory {directory} does not exist");

            var endpointCollection = EndpointCollectionReader.ReadFromDirectory(directory);

            Assert.True(endpointCollection.Endpoints.Count() > 0, $"No endpoints defined in {directory}");

            output.WriteLine(directory);

            if (!TestRunner.HasTestSuite(directory))
            {
                output.WriteLine($"No tests in {directory}");
                return;
            }

            var tests = new ConsoleTestRunner(endpointCollection);

            foreach (var test in tests.Tests)
            {
                output.WriteLine(test.Name);
                var result = await test.ExecuteAsync(endpointCollection, now : tests.Now);

                output.WriteLine(result.ResultAsString);
                Assert.True(result.OK, $"Test case {result.TestCase.Name}, message '{result.Message}'");
            }
        }
예제 #2
0
        public void RunTestsWithReplacement()
        {
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            var result     = testRunner.ExecuteTestAndOutputResult(1);

            Assert.True(result.OK, result.ResultAsString);
        }
예제 #3
0
        public void TestsHaveConstantGetNow()
        {
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            var result     = testRunner.ExecuteTestAndOutputResult(3);

            Assert.True(result.OK, result.ResultAsString);
        }
예제 #4
0
        public void TestsCanHaveDynamicNow()
        {
            dc.DeleteFile("tests\\now.txt");
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            var result     = testRunner.ExecuteTestAndOutputResult(3);

            Assert.True(result.Error, result.ResultAsString);
            Assert.Null(result.Exception);
        }
예제 #5
0
        async public void CanExecuteTest()
        {
            var endpointCollection = EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName);
            var testRunner         = new ConsoleTestRunner(endpointCollection);

            var test   = testRunner.Tests.ElementAt(0);
            var result = await test.ExecuteAsync(endpointCollection, handleErrors : false);

            Assert.True(result.OK);
        }
예제 #6
0
        private EndpointCollection CreateEndpointWithParam(JSONParam jsonParam)
        {
            dc.AddFile("endpoint/endpoint.json", JsonConvert.SerializeObject(DataUtils.CreateScriptEndpoint("endpoint", "script.csscript")));
            dc.AddFile("endpoint/script.csscript", "return GetParam(\"greeting\") + \" \" + GetParam(\"subject\");");
            dc.AddFile("endpoint/params.json", JsonConvert.SerializeObject(new[] {
                jsonParam
            }));

            return(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
        }
예제 #7
0
        public void ReadsFromEndpointJson()
        {
            var endpointCollection = EndpointCollectionReader.ReadFromDirectory("examples/example1");

            var endpoint3 = endpointCollection.Resolve("/statuscode");
            Assert.Equal("StatusCodes", endpoint3.Name);

            var responseCreators = from t in endpoint3.Responses select (SimpleResponseCreator)t.Item2;
            Assert.All(responseCreators, r => Assert.Equal("text/plain", r.ContentType));
            Assert.Equal(new[] { 200, 404, 499 }, from r in responseCreators select (int) r.StatusCode);
        }
예제 #8
0
        async public void CanReadExpectedResponseBodyFromFile()
        {
            var endpointCollection = EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName);
            var testRunner         = new ConsoleTestRunner(endpointCollection);

            var test = testRunner.Tests.ElementAt(2);

            var result = await test.ExecuteAsync(endpointCollection, handleErrors : false);

            Assert.True(result.OK, result.Message);
        }
예제 #9
0
        async public void CanCheckExpectedRequestMatcherSuccess()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "this is a test", expectedrequestmatcher = "Regex 'test'"
            })
                .Validated().CreateTestCase(".");
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.OK);
        }
예제 #10
0
        public async Task TestRunnerKeepsTrackOfTestCoverage()
        {
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            await testRunner.TestAllAsync(false, true);

            var coverageInfo = testRunner.GetCoverageInfo();

            Assert.NotNull(coverageInfo);

            Assert.Equal(new[] { "foo", "GetNow" }, coverageInfo.EndpointsCovered);
            Assert.Equal(0, coverageInfo.EndpointsNotCovered.Length);
        }
예제 #11
0
        async public void CanExecuteWithQueryStringFailure()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", querystring = "?a=test", requestbody = "foobar", expectedresponsecreator = "File content.txt"
            })
                .Validated().CreateTestCase(".");
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.OK, result.Message);
            Assert.Null(result.Message);
        }
예제 #12
0
        public void CanGetResultBody()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "this is a test", expectedrequestmatcher = "Regex 'test'"
            })
                .Validated().CreateTestCase(".");
            var result = testcase.GetResponse(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName), null);

            Assert.Equal("FOOBARBOOBAR", result.Item1);
            Assert.Null(result.Item2);
        }
예제 #13
0
        public async Task TrackTestConverageByResponseRule()
        {
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            await testRunner.TestAllAsync(false, false);

            var coverageInfo = testRunner.GetCoverageInfo();

            Assert.NotNull(coverageInfo);

            Assert.Equal(new[] { "foo#0", "GetNow#0" }, coverageInfo.ResponseRulesCovered);
            Assert.Equal(new[] { "foo#1", "foo#2" }, coverageInfo.ResponseRulesNotCovered);
        }
예제 #14
0
        public async Task TestRunnerKeepsTrackOfCoverageWhenRunningSingleTest()
        {
            var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
            await testRunner.ExecuteTestAndOutputResultAsync(0);

            var coverageInfo = testRunner.GetCoverageInfo();

            Assert.NotNull(coverageInfo);

            Assert.Equal(new[] { "foo" }, coverageInfo.EndpointsCovered);
            Assert.Equal(new[] { "GetNow" }, coverageInfo.EndpointsNotCovered);
        }
예제 #15
0
        public async Task PassingTestCase()
        {
            var testcase = new NetmockeryTestCase
            {
                RequestPath = "/statuscode/404",
                ExpectedStatusCode = 404
            };

            Assert.True(testcase.HasExpectations);
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory("examples/example1"), handleErrors: false);
            Assert.True(result.OK);
        }
예제 #16
0
        private void InitializeEndpointCollectionWithGlobalDefaultsOnly()
        {
            var jsonEndpoint1 = new JSONEndpoint
            {
                name      = "foobar",
                pathregex = "foobar",
                responses = new[] {
                    new JSONResponse {
                        match = new JSONRequestMatcher(),
                        file  = "myfile.xml"
                    }
                }
            };

            var jsonEndpoint2 = new JSONEndpoint
            {
                name      = "baz",
                pathregex = "baz",
                responses = new[] {
                    new JSONResponse {
                        match       = new JSONRequestMatcher(),
                        file        = "myfile.xml",
                        contenttype = "text/xml",
                        charset     = "utf-8"
                    }
                }
            };

            var jsonEndpoint3 = new JSONEndpoint
            {
                name      = "lorem",
                pathregex = "ipsum",
                responses = new[] {
                    new JSONResponse {
                        match       = new JSONRequestMatcher(),
                        file        = "myfile.xml",
                        contenttype = "text/xml",
                        statuscode  = "200"
                    }
                }
            };

            directoryCreator.AddFile("defaults.json", JsonConvert.SerializeObject(new JSONDefaults {
                charset = "ascii", contenttype = "application/xml"
            }));
            directoryCreator.AddFile("endpoint1/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint1));
            directoryCreator.AddFile("endpoint2/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint2));
            directoryCreator.AddFile("endpoint3/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint3));

            endpointCollection = EndpointCollectionReader.ReadFromDirectory(directoryCreator.DirectoryName);
        }
예제 #17
0
        async public void CanCheckExpectedResponseCreatorSuccess()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "this is a test", expectedresponsecreator = "File content.txt"
            })
                .Validated().CreateTestCase(".");

            Assert.Equal("File content.txt", testcase.ExpectedResponseCreator);
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.OK, result.Message);
            Assert.Null(result.Message);
        }
예제 #18
0
        private EndpointCollection CreateEndpointWithScript()
        {
            dc.AddFile("endpoint/endpoint.json", JsonConvert.SerializeObject(DataUtils.CreateScriptEndpoint("endpoint", "script.csscript")));
            dc.AddFile("endpoint/script.csscript", "return GetParam(\"greeting\") + \" \" + GetParam(\"subject\");");
            dc.AddFile("endpoint/params.json", JsonConvert.SerializeObject(new[] {
                new JSONParam {
                    name = "greeting", @default = "Hello", description = "foo"
                },
                new JSONParam {
                    name = "subject", @default = "World", description = "foo"
                },
            }));

            return(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));
        }
예제 #19
0
        public async Task FailingTestCase()
        {
            Assert.False(new NetmockeryTestCase().HasExpectations);

            var testcase = new NetmockeryTestCase
            {
                RequestPath = "/statuscode/200",
                ExpectedStatusCode = 404
            };

            Assert.True(testcase.HasExpectations);
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory("examples/example1"), handleErrors: false);
            Assert.False(result.OK);
            Assert.Equal("Expected http status code: 404\nActual: 200", result.Message);
        }
예제 #20
0
        async public void RequestBodyCanBeUnspecified()
        {
            var endpointCollection = EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName);

            var test = new NetmockeryTestCase
            {
                RequestPath            = "/foo/",
                ExpectedRequestMatcher = "Any request",
                ExpectedResponseBody   = "Hello world"
            };

            var result = await test.ExecuteAsync(endpointCollection, false);

            Assert.True(result.OK, result.Message);
        }
예제 #21
0
        async public void CanCheckExpectedResponseCreatorError()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedresponsecreator = "File content.txt"
            })
                .Validated().CreateTestCase(".");

            Assert.True(testcase.HasExpectations);
            Assert.False(testcase.NeedsResponseBody);
            Assert.Equal("File content.txt", testcase.ExpectedResponseCreator);
            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.Error);
            Assert.Equal("Expected response creator: File content.txt\nActual: Execute script myscript.csscript", result.Message);
        }
예제 #22
0
        async public Task CanCheckExpectedCharSetError()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcharset = "utf-8"
            })
                .Validated().CreateTestCase(".");

            Assert.Equal("utf-8", testcase.ExpectedCharSet);

            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.Null(result.Exception);
            Assert.True(result.Error);
            Assert.Equal("Expected charset: 'utf-8'\nActual: 'us-ascii'", result.Message);
        }
예제 #23
0
        async public Task CanCheckExpectedContentTypeSuccess()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcontenttype = "text/xml"
            })
                .Validated().CreateTestCase(".");

            Assert.True(testcase.HasExpectations);
            Assert.True(testcase.NeedsResponseBody);
            Assert.Equal("text/xml", testcase.ExpectedContentType);

            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.OK);
        }
예제 #24
0
        async public Task CanCheckExpectedContentTypeError()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcontenttype = "text/plain"
            })
                .Validated().CreateTestCase(".");

            Assert.Equal("text/plain", testcase.ExpectedContentType);

            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.Null(result.Exception);
            Assert.True(result.Error);
            Assert.Equal("Expected contenttype: 'text/plain'\nActual: 'text/xml'", result.Message);
        }
        public void EndpointsInitializedCorrectly()
        {
            var endpointCollection = EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName);

            Assert.Equal(dc.DirectoryName, endpointCollection.SourceDirectory);
            Assert.Equal(2, endpointCollection.Endpoints.Count());
            var ep0 = endpointCollection.Get("Endpoint1");

            Assert.Equal("Endpoint1", ep0.Name);
            Assert.Equal("^/ep1/", ep0.PathRegex);
            Assert.Equal(0, ep0.Responses.Count());
            Assert.Equal(Path.Combine(dc.DirectoryName, "endpoint1"), ep0.Directory);

            var ep1 = endpointCollection.Get("foo");

            Assert.Equal(2, ep1.Responses.Count());
        }
예제 #26
0
        async public Task CanCheckExpectedCharSetSuccess()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedcharset = "us-ascii"
            })
                .Validated().CreateTestCase(".");

            Assert.True(testcase.HasExpectations);
            Assert.True(testcase.NeedsResponseBody);
            Assert.Equal("us-ascii", testcase.ExpectedCharSet);

            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.Null(result.Exception);
            Assert.Equal(null, result.Message);
            Assert.True(result.OK);
        }
예제 #27
0
        private void InitializeEndpointCollectionWithoutDefaults()
        {
            var jsonEndpoint1 = new JSONEndpoint
            {
                name      = "foobar",
                pathregex = "foobar",
                responses = new[] {
                    new JSONResponse {
                        match = new JSONRequestMatcher(),
                        file  = "myfile.xml"
                    }
                }
            };

            directoryCreator.AddFile("endpoint1/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint1));

            endpointCollection = EndpointCollectionReader.ReadFromDirectory(directoryCreator.DirectoryName);
        }
예제 #28
0
        async public void CanCheckExpectedRequestMatcherError()
        {
            var testcase =
                (new JSONTest {
                name = "checksomething", requestpath = "/foo/", requestbody = "foobar", expectedrequestmatcher = "Regex 'test'"
            })
                .Validated().CreateTestCase(".");

            Assert.True(testcase.HasExpectations);
            Assert.False(testcase.NeedsResponseBody);
            Assert.Equal("Regex 'test'", testcase.ExpectedRequestMatcher);
            Assert.Equal("foobar", testcase.RequestBody);

            var result = await testcase.ExecuteAsync(EndpointCollectionReader.ReadFromDirectory(dc.DirectoryName));

            Assert.True(result.Error);
            Assert.Null(result.Exception);
            Assert.Equal("Expected request matcher: Regex 'test'\nActual: Any request", result.Message);
        }
예제 #29
0
        private void InitializeEndpointCollectionWithGlobalAndEndpointDefaults()
        {
            var jsonEndpoint1 = new JSONEndpoint
            {
                name      = "noendpointdefaults",
                pathregex = "noendpointdefaults",
                responses = new[] {
                    new JSONResponse {
                        match = new JSONRequestMatcher(),
                        file  = "myfile.xml"
                    }
                }
            };

            var jsonEndpoint2 = new JSONEndpoint
            {
                name      = "endpointdefaults",
                pathregex = "endpointdefaults",
                responses = new[] {
                    new JSONResponse {
                        match = new JSONRequestMatcher(),
                        file  = "myfile.xml",
                    }
                }
            };
            var globalDefaults = new JSONDefaults {
                charset = "ascii", contenttype = "application/xml"
            };
            var endpointDefaults = new JSONDefaults {
                charset = "UTF-7", contenttype = "text/plain"
            };

            directoryCreator.AddFile("defaults.json", JsonConvert.SerializeObject(globalDefaults));
            directoryCreator.AddFile("endpoint1/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint1));
            directoryCreator.AddFile("endpoint2/endpoint.json", JsonConvert.SerializeObject(jsonEndpoint2));
            directoryCreator.AddFile("endpoint2/defaults.json", JsonConvert.SerializeObject(endpointDefaults));

            endpointCollection = EndpointCollectionReader.ReadFromDirectory(directoryCreator.DirectoryName);
        }
예제 #30
0
 private async Task CheckOutputAsync(string directory, int index)
 {
     var testRunner = new ConsoleTestRunner(EndpointCollectionReader.ReadFromDirectory(directory));
     await testRunner.ShowResponseAsync(index);
 }