def test_uploading_single_spliceserver(self):
found = SpliceServer.objects()
self.assertEquals(len(found), 0)
server = SpliceServer()
server.uuid = "Splice Server Test UUID-1"
server.description = "Description data"
server.hostname = "server.example.com"
server.environment = "environment info"
example = {"objects":[server]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for spliceserver import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/spliceserver/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Response for spliceserver import: Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = SpliceServer.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].uuid, server.uuid)
self.assertEquals(found[0].description, server.description)
self.assertEquals(found[0].hostname, server.hostname)
self.assertEquals(found[0].environment, server.environment)
self.assertIsNotNone(found[0].created)
self.assertIsNotNone(found[0].updated)
def test_uploading_duplicate(self):
found = Product.objects()
self.assertEquals(len(found), 0)
p = Product()
p.product_id = "a"
p.name = "a_name"
p.engineering_ids = ["1"]
p.eng_prods = []
p.attrs = {}
p.created = "2012-12-07T15:35:54.448000"
p.updated = "2012-12-07T15:35:54.448000"
p.save() # <- This is the big difference from test_uploading_single_product
example = {"objects":[p]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for product import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/product/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Product.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].product_id, p.product_id)
def test_uploading_duplicate(self):
found = Rules.objects()
self.assertEquals(len(found), 0)
version = "test version a.b"
data = "here's the data"
r = Rules()
r.version = version
r.data = data
r.save() # <-- main diff from above test_single....
example = {"objects": [r]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for rules import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post(
"/api/v1/rules/",
format="json",
data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem,
)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Rules.objects()
self.assertEquals(len(found), 1) # <-- ensure we didn't save a dup
self.assertEquals(found[0].version, version)
self.assertEquals(found[0].data, data)
def test_upload_newer(self):
##
# A newer version will be saved, but not it doesn't delete the older, this is diff than other API tests
##
found = Rules.objects()
self.assertEquals(len(found), 0)
older = Rules()
older.version = "0"
older.data = "older data"
older.save()
version = "1"
data = "here's the data"
newer = Rules()
newer.version = version
newer.data = data
example = {"objects": [newer]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for rules import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post(
"/api/v1/rules/",
format="json",
data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem,
)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Rules.objects()
self.assertEquals(len(found), 2)
for item in found:
self.assertIn(item.version, (newer.version, older.version))
def test_upload_older(self):
##
# We want to accept an older upload, this is diff than most of the other API tests
##
found = Rules.objects()
self.assertEquals(len(found), 0)
version = "1"
data = "here's the data"
newer = Rules()
newer.version = version
newer.data = data
newer.save() # <-- main diff from above test_single....
older = Rules()
older.version = "0"
older.data = "older data"
example = {"objects": [older]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for rules import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post(
"/api/v1/rules/",
format="json",
data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem,
)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Rules.objects()
self.assertEquals(len(found), 2)
self.assertEquals(found[0].version, newer.version)
self.assertEquals(found[0].data, newer.data)
def test_uploading_single_pool(self):
found = Pool.objects()
self.assertEquals(len(found), 0)
datestr = "2012-12-06T11:13:06.432367+00:00"
p = Pool()
p.uuid = "a"
p.account = 1
p.active = True
p.contract = 1
p.product_id = "something"
p.product_name = "something_name"
p.product_attributes = {}
p.provided_products = []
p.created = datestr
p.start_date = datestr
p.end_date = datestr
p.updated = datestr
p.quantity = 0
example = {"objects":[p]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for pool import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/pool/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Pool.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].uuid, p.uuid)
self.assertEquals(found[0].account, p.account)
self.assertEquals(found[0].active, p.active)
self.assertEquals(found[0].contract, p.contract)
self.assertEquals(found[0].product_id, p.product_id)
self.assertEquals(found[0].product_name, p.product_name)
self.assertEquals(found[0].product_attributes, p.product_attributes)
self.assertEquals(found[0].provided_products, p.provided_products)
self.assertEquals(found[0].quantity, p.quantity)
self.assertEquals(type(found[0].created), datetime.datetime)
self.assertEquals(str(found[0].created), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(type(found[0].updated), datetime.datetime)
self.assertEquals(str(found[0].updated), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(type(found[0].start_date), datetime.datetime)
self.assertEquals(str(found[0].start_date), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(type(found[0].end_date), datetime.datetime)
self.assertEquals(str(found[0].end_date), "2012-12-06 11:13:06.432000+00:00")
def test_upload_newer_spliceserver(self):
found = SpliceServer.objects()
self.assertEquals(len(found), 0)
# Create 'newer' server and save to DB
orig_uuid = "Splice Server UUID"
orig_description = "Original Description"
orig_hostname = "Original.hostname.com"
orig_environment = "Original environment"
older = SpliceServer()
older.uuid = orig_uuid
older.description = orig_description
older.hostname = orig_hostname
older.environment = orig_environment
older.created = "2011-01-01T11:13:06.432367"
older.updated = "2012-12-01T11:13:06.432367"
older.save()
found = SpliceServer.objects()
self.assertEquals(len(found), 1)
# Create 'older' which is one month older than newer
newer = SpliceServer()
newer.uuid = orig_uuid
newer.description = "Updated description"
newer.hostname = "updated.server.example.com"
newer.environment = "Updated environment info"
newer.created = "2011-01-01T11:13:06.432367"
newer.updated = "2012-12-31T11:13:06.432367+00:00"
example = {"objects": [newer]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for spliceserver import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/spliceserver/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Response for spliceserver import: Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api kept the 'newer' as is and ignored the older
found = SpliceServer.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].uuid, orig_uuid)
self.assertEquals(found[0].description, newer.description)
self.assertEquals(found[0].hostname, newer.hostname)
self.assertEquals(found[0].environment, newer.environment)
self.assertEquals(str(found[0].updated), "2012-12-31 11:13:06.432000+00:00")
def test_upload_newer_product(self):
found = Product.objects()
self.assertEquals(len(found), 0)
# Create 'older' which is one month older than newer
older = Product()
older.product_id = "a"
older.name = "old name"
older.engineering_ids = ["old1"]
older.eng_prods = [{"more old info": 1}]
older.attrs = {"old": "info"}
older.created = "2012-10-01T01:01:01.111111"
older.updated = "2012-10-01T01:01:01.111111"
older.save()
found = Product.objects()
self.assertEquals(len(found), 1)
newer = Product()
newer.product_id = "a"
newer.name = "a_name"
newer.engineering_ids = ["1"]
newer.eng_prods = [{"new_info": 5}]
newer.attrs = {}
newer.created = "2012-12-07T15:35:54.448000"
newer.updated = "2012-12-07T15:35:54.448000"
example = {"objects":[newer]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for product import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/product/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Product.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].product_id, newer.product_id)
self.assertEquals(found[0].name, newer.name)
self.assertEquals(found[0].engineering_ids, newer.engineering_ids)
self.assertEquals(found[0].eng_prods, newer.eng_prods)
self.assertIsNotNone(found[0].created)
self.assertEquals(str(found[0].created), '2012-12-07 15:35:54.448000+00:00')
self.assertIsNotNone(found[0].updated)
self.assertEquals(str(found[0].updated), '2012-12-07 15:35:54.448000+00:00')
def test_uploading_duplicate(self):
found = MarketingProductUsage.objects()
self.assertEquals(len(found), 0)
datestr = "2012-12-06T11:13:06.432367"
mpu = MarketingProductUsage()
mpu.instance_identifier="instance-1"
mpu.splice_server = "ss-1"
mpu.date=datestr
mpu.save()
self.assertEquals(len(found), 1)
example = {"objects":[mpu]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for marketing product usage import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/marketingproductusage/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = MarketingProductUsage.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].instance_identifier, mpu.instance_identifier)
def test_uploading_single_rules(self):
found = Rules.objects()
self.assertEquals(len(found), 0)
version = "test version a.b"
data = "here's the data"
r = Rules()
r.version = version
r.data = data
example = {"objects":[r]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for rules import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/rules/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Rules.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].version, version)
self.assertEquals(found[0].data, data)
def _request(self, request_type, method, body=None, gzip_body=False, decode_json=True):
"""
@param request_type: HTTP request such as 'GET', 'PUT', 'POST'
@param method: combined with the URL specified by 'handler' to form the full URL end point
@param body: contents of this request
@param gzip_body: optional boolean, default value 'false' leaves body as is
'true' will compress the body
@return:
"""
if self.username and self.password:
# add the basic auth info to headers
self.set_basic_auth()
conn = self.__get_connection()
url = self.handler + method
headers = self.headers
if body:
# Use customized JSON encoder to handle Mongo objects
body = utils.obj_to_json(body)
if gzip_body:
headers["content-encoding"] = "gzip"
orig_body = body
body = self._gzip_data(body)
_LOG.info("Request to '%s' compressed body from %s bytes to %s bytes" % (url, len(orig_body), len(body)))
_LOG.info("Sending '%s' to '%s' \n\twith headers '%s'" % (request_type, url, headers))
conn.request(request_type, url, body=body, headers=headers)
response = conn.getresponse()
response_body = response.read()
if response.getheader('content-encoding', '') == 'gzip':
data = StringIO.StringIO(response_body)
gzipper = gzip.GzipFile(fileobj=data)
response_body = gzipper.read()
_LOG.info("Received '%s' from '%s %s'" % (response.status, request_type, url))
if response.status in [200, 202] and response_body:
_LOG.info("Response body = \n'%s'" % (response_body))
if decode_json:
response_body = json.loads(response_body)
return response.status, response_body
def test_uploading_duplicate(self):
#
# Similar to test_uploading_single_pool, except for this test we will save the Pool object we create
# then upload the same exact data and verify we have only 1 record in the DB...no duplicate should be present.
#
found = Pool.objects()
self.assertEquals(len(found), 0)
datestr = "2012-12-06T11:13:06.432367"
p = Pool()
p.uuid = "a"
p.account = 1
p.active = True
p.contract = 1
p.product_id = "something"
p.product_name = "something_name"
p.product_attributes = {}
p.provided_products = []
p.created = datestr
p.start_date = datestr
p.end_date = datestr
p.updated = datestr
p.quantity = 0
p.save()
self.assertEquals(len(found), 1)
example = {"objects":[p]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for pool import with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/pool/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
self.assertEquals(resp.status_code, 204)
# Now check that the server api saved the object as expected
found = Pool.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].uuid, p.uuid)
def pong(self):
message = {"pong": str(datetime.now(tzutc()))}
return http.HttpAccepted(utils.obj_to_json(message))
parser.add_option('--password', action='store', default=default_password,
help="Password, default is %s" % default_password)
(opts, args) = parser.parse_args()
host = opts.host
port = opts.port
https = not opts.http
username = opts.user
password = opts.password
if not host:
print "Please re-run with --host"
sys.exit(1)
pools = get_pools(host, port, username, password, https)
pools_json = utils.obj_to_json(pools, indent=2)
pools_file = open("./pools.json", "w")
try:
pools_file.write("{\"objects\": ")
pools_file.write(pools_json)
pools_file.write("}")
finally:
pools_file.close()
products = get_products(host, port, username, password, https)
products_json = utils.obj_to_json(products, indent=2)
products_file = open("./products.json", "w")
try:
products_file.write("{\"objects\": ")
products_file.write(products_json)
products_file.write("}")
def test_upload_newer_spliceserver(self):
found = Pool.objects()
self.assertEquals(len(found), 0)
# Create 'older' pool and save to DB
older = Pool()
older.uuid = "a"
older.account = 20
older.contract = 400
older.active = False
older.product_id = "something older"
older.product_name = "something older name"
older.product_attributes = {}
older.provided_products = []
older.created = "2012-11-06T11:13:06.432367+00:00"
older.updated = "2012-11-06T11:13:06.432367+00:00" # 1 month older
older.start_date = older.updated
older.end_date = older.updated
older.quantity = 1
older.save()
found = Pool.objects()
self.assertEquals(len(found), 1)
datestr = "2012-12-06T11:13:06.432367+00:00"
newer = Pool()
newer.uuid = older.uuid
newer.account = 1
newer.active = True
newer.contract = 1
newer.product_id = "something"
newer.product_name = "something_name"
newer.product_attributes = {}
newer.provided_products = []
newer.created = datestr
newer.start_date = datestr
newer.end_date = datestr
newer.updated = datestr
newer.quantity = 0
example = {"objects": [newer]}
post_data = utils.obj_to_json(example)
LOG.info("Calling api for pool with post data: '%s'" % (post_data))
resp = self.raw_api_client.post('/api/v1/pool/', format='json', data=post_data,
SSL_CLIENT_CERT=self.expected_valid_splice_server_identity_pem)
LOG.info("Status Code: %s, Response: %s" % (resp.status_code, resp))
self.assertEquals(resp.status_code, 204)
# Now check that the server api kept the 'newer' as is and ignored the older
found = Pool.objects()
self.assertEquals(len(found), 1)
self.assertEquals(found[0].uuid, newer.uuid)
self.assertEquals(found[0].active, newer.active)
self.assertEquals(found[0].account, newer.account)
self.assertEquals(found[0].contract, newer.contract)
self.assertEquals(found[0].quantity, newer.quantity)
self.assertEquals(found[0].product_id, newer.product_id)
self.assertEquals(found[0].product_name, newer.product_name)
self.assertEquals(found[0].product_attributes, newer.product_attributes)
self.assertEquals(found[0].provided_products, newer.provided_products)
self.assertEquals(str(found[0].created), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(str(found[0].updated), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(str(found[0].start_date), "2012-12-06 11:13:06.432000+00:00")
self.assertEquals(str(found[0].end_date), "2012-12-06 11:13:06.432000+00:00")
