1#!/usr/bin env python
2
3from tests.unit import AWSMockServiceTestCase
4
5from boto.cloudsearch.domain import Domain
6from boto.cloudsearch.layer1 import Layer1
7
8class TestCloudSearchCreateDomain(AWSMockServiceTestCase):
9    connection_class = Layer1
10
11    def default_body(self):
12        return b"""
13<CreateDomainResponse xmlns="http://cloudsearch.amazonaws.com/doc/2011-02-01">
14  <CreateDomainResult>
15    <DomainStatus>
16      <SearchPartitionCount>0</SearchPartitionCount>
17      <SearchService>
18        <Arn>arn:aws:cs:us-east-1:1234567890:search/demo</Arn>
19        <Endpoint>search-demo-userdomain.us-east-1.cloudsearch.amazonaws.com</Endpoint>
20      </SearchService>
21      <NumSearchableDocs>0</NumSearchableDocs>
22      <Created>true</Created>
23      <DomainId>1234567890/demo</DomainId>
24      <Processing>false</Processing>
25      <SearchInstanceCount>0</SearchInstanceCount>
26      <DomainName>demo</DomainName>
27      <RequiresIndexDocuments>false</RequiresIndexDocuments>
28      <Deleted>false</Deleted>
29      <DocService>
30        <Arn>arn:aws:cs:us-east-1:1234567890:doc/demo</Arn>
31        <Endpoint>doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com</Endpoint>
32      </DocService>
33    </DomainStatus>
34  </CreateDomainResult>
35  <ResponseMetadata>
36    <RequestId>00000000-0000-0000-0000-000000000000</RequestId>
37  </ResponseMetadata>
38</CreateDomainResponse>
39"""
40
41    def test_create_domain(self):
42        self.set_http_response(status_code=200)
43        api_response = self.service_connection.create_domain('demo')
44
45        self.assert_request_parameters({
46            'Action': 'CreateDomain',
47            'DomainName': 'demo',
48            'Version': '2011-02-01',
49        })
50
51    def test_cloudsearch_connect_result_endpoints(self):
52        """Check that endpoints & ARNs are correctly returned from AWS"""
53
54        self.set_http_response(status_code=200)
55        api_response = self.service_connection.create_domain('demo')
56        domain = Domain(self, api_response)
57
58        self.assertEqual(domain.doc_service_arn,
59                         "arn:aws:cs:us-east-1:1234567890:doc/demo")
60        self.assertEqual(
61            domain.doc_service_endpoint,
62            "doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com")
63        self.assertEqual(domain.search_service_arn,
64                         "arn:aws:cs:us-east-1:1234567890:search/demo")
65        self.assertEqual(
66            domain.search_service_endpoint,
67            "search-demo-userdomain.us-east-1.cloudsearch.amazonaws.com")
68
69    def test_cloudsearch_connect_result_statuses(self):
70        """Check that domain statuses are correctly returned from AWS"""
71        self.set_http_response(status_code=200)
72        api_response = self.service_connection.create_domain('demo')
73        domain = Domain(self, api_response)
74
75        self.assertEqual(domain.created, True)
76        self.assertEqual(domain.processing, False)
77        self.assertEqual(domain.requires_index_documents, False)
78        self.assertEqual(domain.deleted, False)
79
80    def test_cloudsearch_connect_result_details(self):
81        """Check that the domain information is correctly returned from AWS"""
82        self.set_http_response(status_code=200)
83        api_response = self.service_connection.create_domain('demo')
84        domain = Domain(self, api_response)
85
86        self.assertEqual(domain.id, "1234567890/demo")
87        self.assertEqual(domain.name, "demo")
88
89    def test_cloudsearch_documentservice_creation(self):
90        self.set_http_response(status_code=200)
91        api_response = self.service_connection.create_domain('demo')
92        domain = Domain(self, api_response)
93
94        document = domain.get_document_service()
95
96        self.assertEqual(
97            document.endpoint,
98            "doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com")
99
100    def test_cloudsearch_searchservice_creation(self):
101        self.set_http_response(status_code=200)
102        api_response = self.service_connection.create_domain('demo')
103        domain = Domain(self, api_response)
104
105        search = domain.get_search_service()
106
107        self.assertEqual(
108            search.endpoint,
109            "search-demo-userdomain.us-east-1.cloudsearch.amazonaws.com")
110
111
112class CloudSearchConnectionDeletionTest(AWSMockServiceTestCase):
113    connection_class = Layer1
114
115    def default_body(self):
116        return b"""
117<DeleteDomainResponse xmlns="http://cloudsearch.amazonaws.com/doc/2011-02-01">
118  <DeleteDomainResult>
119    <DomainStatus>
120      <SearchPartitionCount>0</SearchPartitionCount>
121      <SearchService>
122        <Arn>arn:aws:cs:us-east-1:1234567890:search/demo</Arn>
123        <Endpoint>search-demo-userdomain.us-east-1.cloudsearch.amazonaws.com</Endpoint>
124      </SearchService>
125      <NumSearchableDocs>0</NumSearchableDocs>
126      <Created>true</Created>
127      <DomainId>1234567890/demo</DomainId>
128      <Processing>false</Processing>
129      <SearchInstanceCount>0</SearchInstanceCount>
130      <DomainName>demo</DomainName>
131      <RequiresIndexDocuments>false</RequiresIndexDocuments>
132      <Deleted>false</Deleted>
133      <DocService>
134        <Arn>arn:aws:cs:us-east-1:1234567890:doc/demo</Arn>
135        <Endpoint>doc-demo-userdomain.us-east-1.cloudsearch.amazonaws.com</Endpoint>
136      </DocService>
137    </DomainStatus>
138  </DeleteDomainResult>
139  <ResponseMetadata>
140    <RequestId>00000000-0000-0000-0000-000000000000</RequestId>
141  </ResponseMetadata>
142</DeleteDomainResponse>
143"""
144
145    def test_cloudsearch_deletion(self):
146        """
147        Check that the correct arguments are sent to AWS when creating a
148        cloudsearch connection.
149        """
150        self.set_http_response(status_code=200)
151        api_response = self.service_connection.delete_domain('demo')
152
153        self.assert_request_parameters({
154            'Action': 'DeleteDomain',
155            'DomainName': 'demo',
156            'Version': '2011-02-01',
157        })
158
159
160class CloudSearchConnectionIndexDocumentTest(AWSMockServiceTestCase):
161    connection_class = Layer1
162
163    def default_body(self):
164        return b"""
165<IndexDocumentsResponse xmlns="http://cloudsearch.amazonaws.com/doc/2011-02-01">
166  <IndexDocumentsResult>
167    <FieldNames>
168      <member>average_score</member>
169      <member>brand_id</member>
170      <member>colors</member>
171      <member>context</member>
172      <member>context_owner</member>
173      <member>created_at</member>
174      <member>creator_id</member>
175      <member>description</member>
176      <member>file_size</member>
177      <member>format</member>
178      <member>has_logo</member>
179      <member>has_messaging</member>
180      <member>height</member>
181      <member>image_id</member>
182      <member>ingested_from</member>
183      <member>is_advertising</member>
184      <member>is_photo</member>
185      <member>is_reviewed</member>
186      <member>modified_at</member>
187      <member>subject_date</member>
188      <member>tags</member>
189      <member>title</member>
190      <member>width</member>
191    </FieldNames>
192  </IndexDocumentsResult>
193  <ResponseMetadata>
194    <RequestId>eb2b2390-6bbd-11e2-ab66-93f3a90dcf2a</RequestId>
195  </ResponseMetadata>
196</IndexDocumentsResponse>
197"""
198
199    def test_cloudsearch_index_documents(self):
200        """
201        Check that the correct arguments are sent to AWS when indexing a
202        domain.
203        """
204        self.set_http_response(status_code=200)
205        api_response = self.service_connection.index_documents('demo')
206
207        self.assert_request_parameters({
208            'Action': 'IndexDocuments',
209            'DomainName': 'demo',
210            'Version': '2011-02-01',
211        })
212
213    def test_cloudsearch_index_documents_resp(self):
214        """
215        Check that the AWS response is being parsed correctly when indexing a
216        domain.
217        """
218        self.set_http_response(status_code=200)
219        api_response = self.service_connection.index_documents('demo')
220
221        self.assertEqual(api_response, ['average_score', 'brand_id', 'colors',
222                                        'context', 'context_owner',
223                                        'created_at', 'creator_id',
224                                        'description', 'file_size', 'format',
225                                        'has_logo', 'has_messaging', 'height',
226                                        'image_id', 'ingested_from',
227                                        'is_advertising', 'is_photo',
228                                        'is_reviewed', 'modified_at',
229                                        'subject_date', 'tags', 'title',
230                                        'width'])
231