googlecloud 0.0.4 → 0.0.6

data/packages/gsutil/boto/tests/mturk/create_hit_test.py

@@ -0,0 +1,21 @@
+import unittest
+import os
+from boto.mturk.question import QuestionForm
+
+from common import MTurkCommon
+
+class TestHITCreation(MTurkCommon):
+	def testCallCreateHitWithOneQuestion(self):
+		create_hit_rs = self.conn.create_hit(
+			question=self.get_question(),
+			**self.get_hit_params()
+			)
+
+	def testCallCreateHitWithQuestionForm(self):
+		create_hit_rs = self.conn.create_hit(
+			questions=QuestionForm([self.get_question()]),
+			**self.get_hit_params()
+			)
+
+if __name__ == '__main__':
+	unittest.main()

data/packages/gsutil/boto/tests/mturk/create_hit_with_qualifications.py

@@ -0,0 +1,16 @@
+from boto.mturk.connection import MTurkConnection
+from boto.mturk.question import ExternalQuestion
+from boto.mturk.qualification import Qualifications, PercentAssignmentsApprovedRequirement
+
+def test():
+    q = ExternalQuestion(external_url="http://websort.net/s/F3481C", frame_height=800)
+    conn = MTurkConnection(host='mechanicalturk.sandbox.amazonaws.com')
+    keywords=['boto', 'test', 'doctest']
+    qualifications = Qualifications()
+    qualifications.add(PercentAssignmentsApprovedRequirement(comparator="GreaterThan", integer_value="95"))
+    create_hit_rs = conn.create_hit(question=q, lifetime=60*65, max_assignments=2, title="Boto External Question Test", keywords=keywords, reward = 0.05, duration=60*6, approval_delay=60*60, annotation='An annotation from boto external question test', qualifications=qualifications)
+    assert(create_hit_rs.status == True)
+    print create_hit_rs.HITTypeId
+
+if __name__ == "__main__":
+    test()

data/packages/gsutil/boto/tests/mturk/hit_persistence.py

@@ -0,0 +1,27 @@
+import unittest
+import pickle
+
+from common import MTurkCommon
+
+class TestHITPersistence(MTurkCommon):
+	def create_hit_result(self):
+		return self.conn.create_hit(
+			question=self.get_question(), **self.get_hit_params()
+			)
+
+	def test_pickle_hit_result(self):
+		result = self.create_hit_result()
+		new_result = pickle.loads(pickle.dumps(result))
+
+	def test_pickle_deserialized_version(self):
+		"""
+		It seems the technique used to store and reload the object must
+		result in an equivalent object, or subsequent pickles may fail.
+		This tests a double-pickle to elicit that error.
+		"""
+		result = self.create_hit_result()
+		new_result = pickle.loads(pickle.dumps(result))
+		pickle.dumps(new_result)
+
+if __name__ == '__main__':
+	unittest.main()

data/packages/gsutil/boto/tests/mturk/mocks.py

@@ -0,0 +1,11 @@
+from boto.mturk.connection import MTurkConnection as RealMTurkConnection
+
+class MTurkConnection(RealMTurkConnection):
+	"""
+	Mock MTurkConnection that doesn't connect, but instead just prepares
+	the request and captures information about its usage.
+	"""
+	
+	def _process_request(self, *args, **kwargs):
+		saved_args = self.__dict__.setdefault('_mock_saved_args', dict())
+		saved_args['_process_request'] = (args, kwargs)

data/packages/gsutil/boto/tests/mturk/reviewable_hits.doctest

@@ -0,0 +1,129 @@
+>>> import uuid
+>>> import datetime
+>>> from _init_environment import MTurkConnection, mturk_host
+>>> from boto.mturk.question import Question, QuestionContent, AnswerSpecification, FreeTextAnswer
+
+>>> conn = MTurkConnection(host=mturk_host)
+
+# create content for a question
+>>> qn_content = QuestionContent()
+>>> qn_content.append_field('Title', 'Boto no hit type question content')
+>>> qn_content.append_field('Text', 'What is a boto no hit type?')
+
+# create the question specification
+>>> qn = Question(identifier=str(uuid.uuid4()),
+...               content=qn_content,
+...               answer_spec=AnswerSpecification(FreeTextAnswer()))
+
+# now, create the actual HIT for the question without using a HIT type
+# NOTE - the response_groups are specified to get back additional information for testing
+>>> keywords=['boto', 'test', 'doctest']
+>>> create_hit_rs = conn.create_hit(question=qn,
+...                                 lifetime=60*65,
+...                                 max_assignments=1,
+...                                 title='Boto Hit to be Reviewed',
+...                                 description='Boto reviewable_hits description',
+...                                 keywords=keywords,
+...                                 reward=0.23,
+...                                 duration=60*6,
+...                                 approval_delay=60*60,
+...                                 annotation='An annotation from boto create_hit test',
+...                                 response_groups=['Minimal',
+...                                                  'HITDetail',
+...                                                  'HITQuestion',
+...                                                  'HITAssignmentSummary',])
+
+# this is a valid request
+>>> create_hit_rs.status
+True
+
+>>> len(create_hit_rs)
+1
+>>> hit = create_hit_rs[0]
+
+# for the requested hit type id
+# the HIT Type Id is a unicode string
+>>> hit_type_id = hit.HITTypeId
+>>> hit_type_id # doctest: +ELLIPSIS
+u'...'
+
+>>> from selenium_support import complete_hit, has_selenium
+>>> if has_selenium(): complete_hit(hit_type_id, response='reviewable_hits_test')
+>>> import time
+
+Give mechanical turk some time to process the hit
+>>> if has_selenium(): time.sleep(10)
+
+# should have some reviewable HIT's returned, especially if returning all HIT type's
+# NOTE: but only if your account has existing HIT's in the reviewable state
+>>> reviewable_rs = conn.get_reviewable_hits()
+
+# this is a valid request
+>>> reviewable_rs.status
+True
+
+>>> len(reviewable_rs) >= 1
+True
+
+# should contain at least one HIT object
+>>> reviewable_rs # doctest: +ELLIPSIS
+[<boto.mturk.connection.HIT instance at ...]
+
+>>> hit_id = reviewable_rs[0].HITId
+
+# check that we can retrieve the assignments for a HIT
+>>> assignments_rs = conn.get_assignments(hit_id)
+
+# this is a valid request
+>>> assignments_rs.status
+True
+
+>>> int(assignments_rs.NumResults) >= 1
+True
+
+>>> len(assignments_rs) == int(assignments_rs.NumResults)
+True
+
+>>> assignments_rs.PageNumber
+u'1'
+
+>>> assignments_rs.TotalNumResults >= 1
+True
+
+# should contain at least one Assignment object
+>>> assignments_rs # doctest: +ELLIPSIS
+[<boto.mturk.connection.Assignment instance at ...]
+
+# should have returned assignments for the requested HIT id
+>>> assignment = assignments_rs[0]
+
+>>> assignment.HITId == hit_id
+True
+
+# should have a valid status
+>>> assignment.AssignmentStatus in ['Submitted', 'Approved', 'Rejected']
+True
+
+# should have returned at least one answer
+>>> len(assignment.answers) > 0
+True
+
+# should contain at least one set of QuestionFormAnswer objects
+>>> assignment.answers # doctest: +ELLIPSIS
+[[<boto.mturk.connection.QuestionFormAnswer instance at ...]]
+
+>>> answer = assignment.answers[0][0]
+
+# the answer should have exactly one field
+>>> len(answer.fields)
+1
+
+>>> qid, text = answer.fields[0]
+
+>>> text # doctest: +ELLIPSIS
+u'...'
+
+# question identifier should be a unicode string
+>>> qid # doctest: +ELLIPSIS
+u'...'
+

data/packages/gsutil/boto/tests/mturk/run-doctest.py

@@ -0,0 +1,13 @@
+import argparse
+import doctest
+
+parser = argparse.ArgumentParser(
+	description="Run a test by name"
+	)
+parser.add_argument('test_name')
+args = parser.parse_args()
+
+doctest.testfile(
+	args.test_name,
+	optionflags=doctest.REPORT_ONLY_FIRST_FAILURE
+	)

data/packages/gsutil/boto/tests/mturk/search_hits.doctest

@@ -0,0 +1,16 @@
+>>> from _init_environment import MTurkConnection, mturk_host
+>>> conn = MTurkConnection(host=mturk_host)
+
+# should have some HIT's returned by a search (but only if your account has existing HIT's)
+>>> search_rs = conn.search_hits()
+
+# this is a valid request
+>>> search_rs.status
+True
+
+>>> len(search_rs) > 1
+True
+
+>>> search_rs # doctest: +ELLIPSIS
+[<boto.mturk.connection.HIT instance at ...]
+

data/packages/gsutil/boto/tests/mturk/selenium_support.py

@@ -0,0 +1,61 @@
+from __future__ import absolute_import
+from boto.mturk.test.support import unittest
+
+sel_args = ('localhost', 4444, '*chrome', 'https://workersandbox.mturk.com')
+
+class SeleniumFailed(object):
+	def __init__(self, message):
+		self.message = message
+	def __nonzero__(self):
+		return False
+
+def has_selenium():
+	try:
+		from selenium import selenium
+		globals().update(selenium=selenium)
+		sel = selenium(*sel_args)
+		# a little trick to see if the server is responding
+		try:
+			sel.do_command('shutdown', '')
+		except Exception, e:
+			if not 'Server Exception' in str(e):
+				raise
+		result = True
+	except ImportError:
+		result = SeleniumFailed('selenium RC not installed')
+	except Exception:
+		msg = 'Error occurred initializing selenium: %s' % e
+		result = SeleniumFailed(msg)
+
+	# overwrite has_selenium, so the same result is returned every time
+	globals().update(has_selenium=lambda: result)
+	return result
+
+identity = lambda x: x
+
+def skip_unless_has_selenium():
+	res = has_selenium()
+	if not res:
+		return unittest.skip(res.message)
+	return identity
+
+def complete_hit(hit_type_id, response='Some Response'):
+	verificationErrors = []
+	sel = selenium(*sel_args)
+	sel.start()
+	sel.open("/mturk/welcome")
+	sel.click("lnkWorkerSignin")
+	sel.wait_for_page_to_load("30000")
+	sel.type("email", "boto.tester@example.com")
+	sel.type("password", "BotoTest")
+	sel.click("Continue")
+	sel.wait_for_page_to_load("30000")
+	sel.open("/mturk/preview?groupId={hit_type_id}".format(**vars()))
+	sel.click("/accept")
+	sel.wait_for_page_to_load("30000")
+	sel.type("Answer_1_FreeText", response)
+	sel.click("//div[5]/table/tbody/tr[2]/td[1]/input")
+	sel.wait_for_page_to_load("30000")
+	sel.click("link=Sign Out")
+	sel.wait_for_page_to_load("30000")
+	sel.stop()

data/packages/gsutil/boto/tests/mturk/support.py

@@ -0,0 +1,7 @@
+import sys
+
+# use unittest2 under Python 2.6 and earlier.
+if sys.version_info >= (2, 7):
+    import unittest
+else:
+    import unittest2 as unittest

data/packages/gsutil/boto/tests/mturk/test_disable_hit.py

@@ -0,0 +1,11 @@
+from tests.mturk.support import unittest
+
+from common import MTurkCommon
+from boto.mturk.connection import MTurkRequestError
+
+class TestDisableHITs(MTurkCommon):
+	def test_disable_invalid_hit(self):
+		self.assertRaises(MTurkRequestError, self.conn.disable_hit, 'foo')
+
+if __name__ == '__main__':
+	unittest.main()

data/packages/gsutil/boto/tests/test.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python
+# Copyright (c) 2006-2011 Mitch Garnaat http://garnaat.org/
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish, dis-
+# tribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the fol-
+# lowing conditions:
+#
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
+# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+import logging
+import sys
+import unittest
+
+from nose.core import run
+import argparse
+
+
+def main():
+    description = ("Runs boto unit and/or integration tests. "
+                   "Arguments will be passed on to nosetests. "
+                   "See nosetests --help for more information.")
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument('-t', '--service-tests', action="append", default=[],
+                        help="Run tests for a given service.  This will "
+                        "run any test tagged with the specified value, "
+                        "e.g -t s3 -t ec2")
+    known_args, remaining_args = parser.parse_known_args()
+    attribute_args = []
+    for service_attribute in known_args.service_tests:
+        attribute_args.extend(['-a', '!notdefault,' +service_attribute])
+    if not attribute_args:
+        # If the user did not specify any filtering criteria, we at least
+        # will filter out any test tagged 'notdefault'.
+        attribute_args = ['-a', '!notdefault']
+    all_args = [__file__] + attribute_args + remaining_args
+    print "nose command:", ' '.join(all_args)
+    if run(argv=all_args):
+        # run will return True is all the tests pass.  We want
+        # this to equal a 0 rc
+        return 0
+    else:
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

data/packages/gsutil/boto/tests/unit/__init__.py

@@ -0,0 +1,79 @@
+try:
+    import unittest2 as unittest
+except ImportError:
+    import unittest
+import httplib
+
+from mock import Mock
+
+
+class AWSMockServiceTestCase(unittest.TestCase):
+    """Base class for mocking aws services."""
+    # This param is used by the unittest module to display a full
+    # diff when assert*Equal methods produce an error message.
+    maxDiff = None
+    connection_class = None
+
+    def setUp(self):
+        self.https_connection = Mock(spec=httplib.HTTPSConnection)
+        self.https_connection_factory = (
+            Mock(return_value=self.https_connection), ())
+        self.service_connection = self.create_service_connection(
+            https_connection_factory=self.https_connection_factory,
+            aws_access_key_id='aws_access_key_id',
+            aws_secret_access_key='aws_secret_access_key')
+        self.initialize_service_connection()
+
+    def initialize_service_connection(self):
+        self.actual_request = None
+        self.original_mexe = self.service_connection._mexe
+        self.service_connection._mexe = self._mexe_spy
+
+    def create_service_connection(self, **kwargs):
+        if self.connection_class is None:
+            raise ValueError("The connection_class class attribute must be "
+                             "set to a non-None value.")
+        return self.connection_class(**kwargs)
+
+    def _mexe_spy(self, request, *args, **kwargs):
+        self.actual_request = request
+        return self.original_mexe(request, *args, **kwargs)
+
+    def create_response(self, status_code, reason='', header=[], body=None):
+        if body is None:
+            body = self.default_body()
+        response = Mock(spec=httplib.HTTPResponse)
+        response.status = status_code
+        response.read.return_value = body
+        response.reason = reason
+
+        response.getheaders.return_value = header
+        response.msg = dict(header)
+        def overwrite_header(arg, default=None):
+            header_dict = dict(header)
+            if header_dict.has_key(arg):
+                return header_dict[arg]
+            else:
+                return default
+        response.getheader.side_effect = overwrite_header
+
+        return response
+
+    def assert_request_parameters(self, params, ignore_params_values=None):
+        """Verify the actual parameters sent to the service API."""
+        request_params = self.actual_request.params.copy()
+        if ignore_params_values is not None:
+            for param in ignore_params_values:
+                # We still want to check that the ignore_params_values params
+                # are in the request parameters, we just don't need to check
+                # their value.
+                self.assertIn(param, request_params)
+                del request_params[param]
+        self.assertDictEqual(request_params, params)
+
+    def set_http_response(self, status_code, reason='', header=[], body=None):
+        http_response = self.create_response(status_code, reason, header, body)
+        self.https_connection.getresponse.return_value = http_response
+
+    def default_body(self):
+        return ''