public void ListDeploymentsTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <ListDeploymentsRequest>();

            var response = InstantiateClassGenerator.Execute <ListDeploymentsResponse>();

            response.NextToken = null;

            _mockClient.Setup(x => x.ListDeployments(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.ListDeployments(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
        public void ListHealthChecksTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <ListHealthChecksRequest>();

            var response = InstantiateClassGenerator.Execute <ListHealthChecksResponse>();

            response.IsTruncated = false;

            _mockClient.Setup(x => x.ListHealthChecks(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.ListHealthChecks(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
Пример #3
0
        public void DescribeCertificatesTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <DescribeCertificatesRequest>();

            var response = InstantiateClassGenerator.Execute <DescribeCertificatesResponse>();

            response.Marker = null;

            _mockClient.Setup(x => x.DescribeCertificates(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.DescribeCertificates(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
Пример #4
0
        public void GetFindingsReportAccountSummaryTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <GetFindingsReportAccountSummaryRequest>();

            var response = InstantiateClassGenerator.Execute <GetFindingsReportAccountSummaryResponse>();

            response.NextToken = null;

            _mockClient.Setup(x => x.GetFindingsReportAccountSummary(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.GetFindingsReportAccountSummary(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
        public void ListAssociatedApprovalRuleTemplatesForRepositoryTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <ListAssociatedApprovalRuleTemplatesForRepositoryRequest>();

            var response = InstantiateClassGenerator.Execute <ListAssociatedApprovalRuleTemplatesForRepositoryResponse>();

            response.NextToken = null;

            _mockClient.Setup(x => x.ListAssociatedApprovalRuleTemplatesForRepository(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.ListAssociatedApprovalRuleTemplatesForRepository(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
        public void SearchProductsAsAdminTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <SearchProductsAsAdminRequest>();

            var response = InstantiateClassGenerator.Execute <SearchProductsAsAdminResponse>();

            response.NextPageToken = null;

            _mockClient.Setup(x => x.SearchProductsAsAdmin(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.SearchProductsAsAdmin(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
        public void ListServiceActionsForProvisioningArtifactTest__OnlyUsedOnce()
        {
            var request = InstantiateClassGenerator.Execute <ListServiceActionsForProvisioningArtifactRequest>();

            var response = InstantiateClassGenerator.Execute <ListServiceActionsForProvisioningArtifactResponse>();

            response.NextPageToken = null;

            _mockClient.Setup(x => x.ListServiceActionsForProvisioningArtifact(request)).Returns(response);
            var paginator = _mockClient.Object.Paginators.ListServiceActionsForProvisioningArtifact(request);

            // Should work the first time
            paginator.Responses.ToList();

            // Second time should throw an exception
            paginator.Responses.ToList();
        }
Пример #8
0
        public void VerifyEmailIdentityMarshallTest()
        {
            var operation = service_model.FindOperation("VerifyEmailIdentity");

            var request         = InstantiateClassGenerator.Execute <VerifyEmailIdentityRequest>();
            var marshaller      = new VerifyEmailIdentityRequestMarshaller();
            var internalRequest = marshaller.Marshall(request);
            var validator       = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation);

            validator.Validate();


            var payloadResponse = new XmlSampleGenerator(service_model, operation).Execute();
            var context         = new XmlUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, null);
            var response        = VerifyEmailIdentityResponseUnmarshaller.Instance.Unmarshall(context)
                                  as VerifyEmailIdentityResponse;

            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }
Пример #9
0
        public void DescribeEngineDefaultClusterParametersMarshallTest()
        {
            var operation = service_model.FindOperation("DescribeEngineDefaultClusterParameters");

            var request         = InstantiateClassGenerator.Execute <DescribeEngineDefaultClusterParametersRequest>();
            var marshaller      = new DescribeEngineDefaultClusterParametersRequestMarshaller();
            var internalRequest = marshaller.Marshall(request);
            var validator       = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation);

            validator.Validate();


            var payloadResponse = new XmlSampleGenerator(service_model, operation).Execute();
            var context         = new XmlUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, null);
            var response        = DescribeEngineDefaultClusterParametersResponseUnmarshaller.Instance.Unmarshall(context)
                                  as DescribeEngineDefaultClusterParametersResponse;

            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }
Пример #10
0
        public void SetLoadBalancerPoliciesForBackendServerMarshallTest()
        {
            var operation = service_model.FindOperation("SetLoadBalancerPoliciesForBackendServer");

            var request         = InstantiateClassGenerator.Execute <SetLoadBalancerPoliciesForBackendServerRequest>();
            var marshaller      = new SetLoadBalancerPoliciesForBackendServerRequestMarshaller();
            var internalRequest = marshaller.Marshall(request);
            var validator       = new AWSQueryValidator(internalRequest.Parameters, request, service_model, operation);

            validator.Validate();


            var payloadResponse = new XmlSampleGenerator(service_model, operation).Execute();
            var context         = new XmlUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, null);
            var response        = SetLoadBalancerPoliciesForBackendServerResponseUnmarshaller.Instance.Unmarshall(context)
                                  as SetLoadBalancerPoliciesForBackendServerResponse;

            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }
        public void GetComplianceSummaryByConfigRuleMarshallTest()
        {
            var request = InstantiateClassGenerator.Execute<GetComplianceSummaryByConfigRuleRequest>();
            var marshaller = new GetComplianceSummaryByConfigRuleRequestMarshaller();

            var internalRequest = marshaller.Marshall(request);
            var webResponse = new WebResponseData
            {
                Headers = {
                    {"x-amzn-RequestId", Guid.NewGuid().ToString()},
                    {"x-amz-crc32","0"}
                }
            };
            var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("GetComplianceSummaryByConfigRule").ResponseStructure).Execute();
            webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
            UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
            var response = GetComplianceSummaryByConfigRuleResponseUnmarshaller.Instance.Unmarshall(context)
                as GetComplianceSummaryByConfigRuleResponse;
            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }
Пример #12
0
        public void PostContentMarshallTest()
        {
            var operation = service_model.FindOperation("PostContent");

            var request    = InstantiateClassGenerator.Execute <PostContentRequest>();
            var marshaller = new PostContentRequestMarshaller();

            var internalRequest = marshaller.Marshall(request);

            TestTools.RequestValidator.Validate("PostContent", request, internalRequest, service_model);

            var webResponse = new WebResponseData
            {
                Headers =
                {
                    { "Content-Type",                 "Content-Type_Value"                                                                 },
                    { "x-amz-lex-dialog-state",       "x-amz-lex-dialog-state_Value"                                                       },
                    { "x-amz-lex-input-transcript",   "x-amz-lex-input-transcript_Value"                                                   },
                    { "x-amz-lex-intent-name",        "x-amz-lex-intent-name_Value"                                                        },
                    { "x-amz-lex-message",            "x-amz-lex-message_Value"                                                            },
                    { "x-amz-lex-session-attributes", Convert.ToBase64String(Encoding.UTF8.GetBytes("x-amz-lex-session-attributes_Value")) },
                    { "x-amz-lex-slots",              Convert.ToBase64String(Encoding.UTF8.GetBytes("x-amz-lex-slots_Value"))              },
                    { "x-amz-lex-slot-to-elicit",     "x-amz-lex-slot-to-elicit_Value"                                                     },
                    { "x-amzn-RequestId",             Guid.NewGuid().ToString()                                                            },
                    { "x-amz-crc32",                  "0"                                                                                  }
                }
            };

            var payloadResponse = new JsonSampleGenerator(service_model, operation.ResponseStructure).Execute();

            webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(payloadResponse).Length.ToString());
            var context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, webResponse);
            ResponseUnmarshaller unmarshaller = PostContentResponseUnmarshaller.Instance;
            var response = unmarshaller.Unmarshall(context)
                           as PostContentResponse;

            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }
        public void ListDiscoveredResourcesMarshallTest()
        {
            var request = InstantiateClassGenerator.Execute<ListDiscoveredResourcesRequest>();
            var marshaller = new ListDiscoveredResourcesRequestMarshaller();

            var internalRequest = marshaller.Marshall(request);
            var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content);                        
            Comparer.CompareObjectToJson<ListDiscoveredResourcesRequest>(request,jsonRequest);

            var webResponse = new WebResponseData
            {
                Headers = {
                    {"x-amzn-RequestId", Guid.NewGuid().ToString()},
                    {"x-amz-crc32","0"}
                }
            };
            var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("ListDiscoveredResources").ResponseStructure).Execute();
            webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
            UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
            var response = ListDiscoveredResourcesResponseUnmarshaller.Instance.Unmarshall(context)
                as ListDiscoveredResourcesResponse;
            InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
        }