public void GetResults(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int scanId,
            IEnumerable <string> results)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("results", JArray.FromObject(results)));

            httpClientMock.SetupApiCall(sut, CallType.View, "results",
                                        new Parameters
            {
                { "scanId", scanId }
            })
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetResults(scanId);

            // ASSERT
            result.ShouldBeEquivalentTo(results);
            httpClientMock.Verify();
        }
Пример #2
0
 public ZapClient(string host, int port, Protocols protocol = Protocols.http)
 {
     Protocol          = protocol;
     Host              = host;
     Port              = port;
     Acsrf             = new AcsrfComponent(this);
     AjaxSpider        = new AjaxSpiderComponent(this);
     Ascan             = new AscanComponent(this);
     Authentication    = new AuthenticationComponent(this);
     Authorization     = new AuthorizationComponent(this);
     Autoupdate        = new AutoupdateComponent(this);
     Break             = new BreakComponent(this);
     Context           = new ContextComponent(this);
     Core              = new CoreComponent(this);
     ForcedUser        = new ForcedUserComponent(this);
     HttpSessions      = new HttpSessionsComponent(this);
     Params            = new ParamsComponent(this);
     Pscan             = new PscanComponent(this);
     Reveal            = new RevealComponent(this);
     Script            = new ScriptComponent(this);
     Search            = new SearchComponent(this);
     Selenium          = new SeleniumComponent(this);
     SessionManagement = new SessionManagementComponent(this);
     Spider            = new SpiderComponent(this);
     Users             = new UsersComponent(this);
 }
        public void GetStatus(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int scanId,
            int status)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("status", status));

            httpClientMock.SetupApiCall(sut, CallType.View, "status",
                                        new Parameters
            {
                { "scanId", scanId }
            })
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetStatus(scanId);

            // ASSERT
            result.Should().Be(status);
            httpClientMock.Verify();
        }
        public void ScanAsUser(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            string url,
            int contextId,
            int userId,
            int maxChildren,
            int scanId)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("scanAsUser", scanId));

            httpClientMock.SetupApiCall(sut, CallType.Action, "scanAsUser",
                                        new Parameters
            {
                { "url", url },
                { "contextId", contextId },
                { "userId", userId },
                { "maxChildren", maxChildren }
            })
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.ScanAsUser(url, contextId, userId, maxChildren);

            // ASSERT
            result.Should().Be(scanId);
            httpClientMock.Verify();
        }
        public void ComponentName(
            [Greedy] SpiderComponent sut)
        {
            // ACT
            var result = sut.ComponentName;

            // ASSERT
            result.Should().Be("spider");
        }
        public void ClearExcludedFromScan(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "clearExcludedFromScan")
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.ClearExcludedFromScan();

            // ASSERT
            httpClientMock.Verify();
        }
        public void ResumeAllScans(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "resumeAllScans")
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.ResumeAllScans();

            // ASSERT
            httpClientMock.Verify();
        }
        public void Resume(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int scanId)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "resume",
                                        new Parameters
            {
                { "scanId", scanId }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.Resume(scanId);

            // ASSERT
            httpClientMock.Verify();
        }
        public void ExcludeFromScan(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            string regex)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "excludeFromScan",
                                        new Parameters
            {
                { "regex", regex }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.ExcludeFromScan(regex);

            // ASSERT
            httpClientMock.Verify();
        }
        public void SetOptionUserAgent(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            string value)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "setOptionUserAgent",
                                        new Parameters
            {
                { "String", value }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.SetOptionUserAgent(value);

            // ASSERT
            httpClientMock.Verify();
        }
        public void GetOptionUserAgent(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            string userAgent)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("UserAgent", userAgent));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionUserAgent")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionUserAgent();

            // ASSERT
            result.Should().Be(userAgent);
            httpClientMock.Verify();
        }
        public void GetOptionShowAdvancedDialog(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            bool showAdvancedDialog)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("ShowAdvancedDialog", showAdvancedDialog));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionShowAdvancedDialog")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionShowAdvancedDialog();

            // ASSERT
            result.Should().Be(showAdvancedDialog);
            httpClientMock.Verify();
        }
        public void GetOptionSendRefererHeader(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            bool sendRefererHeader)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("SendRefererHeader", sendRefererHeader));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionSendRefererHeader")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionSendRefererHeader();

            // ASSERT
            result.Should().Be(sendRefererHeader);
            httpClientMock.Verify();
        }
        public void GetOptionRequestWaitTime(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int requestWaitTime)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("RequestWaitTime", requestWaitTime));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionRequestWaitTime")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionRequestWaitTime();

            // ASSERT
            result.Should().Be(requestWaitTime);
            httpClientMock.Verify();
        }
        public void GetOptionProcessForm(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            bool processForm)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("ProcessForm", processForm));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionProcessForm")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionProcessForm();

            // ASSERT
            result.Should().Be(processForm);
            httpClientMock.Verify();
        }
        public void GetOptionMaxScansInUI(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int maxScansInUI)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("MaxScansInUI", maxScansInUI));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionMaxScansInUI")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionMaxScansInUI();

            // ASSERT
            result.Should().Be(maxScansInUI);
            httpClientMock.Verify();
        }
        public void GetScans(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            IEnumerable <SpiderScan> scans)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("scans", JArray.FromObject(scans)));

            httpClientMock.SetupApiCall(sut, CallType.View, "scans")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetScans();

            // ASSERT
            result.ShouldBeEquivalentTo(scans);
            httpClientMock.Verify();
        }
        public void SetOptionParseRobotsTxt(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            bool value)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "setOptionParseRobotsTxt",
                                        new Parameters
            {
                { "Boolean", value }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.SetOptionParseRobotsTxt(value);

            // ASSERT
            httpClientMock.Verify();
        }
        public void GetOptionHandleParameters(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            HandleParametersOption handleParameters)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("HandleParameters", handleParameters));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionHandleParameters")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
            var result = sut.GetOptionHandleParameters();

            // ASSERT
            result.Should().Be(handleParameters);
            httpClientMock.Verify();
        }
        public void SetOptionMaxScansInUI(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            int value)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "setOptionMaxScansInUI",
                                        new Parameters
            {
                { "Integer", value }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.SetOptionMaxScansInUI(value);

            // ASSERT
            httpClientMock.Verify();
        }
        public void SetOptionHandleParameters(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            HandleParametersOption value)
        {
            // ARRANGE
            httpClientMock.SetupApiCall(sut, CallType.Action, "setOptionHandleParameters",
                                        new Parameters
            {
                { "String", value.ToString().ToUpperInvariant() }
            })
            .ReturnsOkResult()
            .Verifiable();

            // ACT
            sut.SetOptionHandleParameters(value);

            // ASSERT
            httpClientMock.Verify();
        }
        public void GetOptionScopeText(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            string scopeText)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("ScopeText", scopeText));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionScopeText")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
#pragma warning disable CS0618 // Type or member is obsolete
            var result = sut.GetOptionScopeText();
#pragma warning restore CS0618 // Type or member is obsolete

            // ASSERT
            result.Should().Be(scopeText);
            httpClientMock.Verify();
        }
        public void GetOptionDomainsAlwaysInScope(
            [Frozen] Mock <IHttpClient> httpClientMock,
            [Greedy] SpiderComponent sut,
            IEnumerable <string> domainsAlwaysInScope)
        {
            // ARRANGE
            var json = new JObject(
                new JProperty("DomainsAlwaysInScope", domainsAlwaysInScope.ToJsonStringList()));

            httpClientMock.SetupApiCall(sut, CallType.View, "optionDomainsAlwaysInScope")
            .Returns(json.ToString())
            .Verifiable();

            // ACT
#pragma warning disable CS0618 // Type or member is obsolete
            var result = sut.GetOptionDomainsAlwaysInScope();
#pragma warning restore CS0618 // Type or member is obsolete

            // ASSERT
            result.ShouldBeEquivalentTo(domainsAlwaysInScope);
            httpClientMock.Verify();
        }