def test_get_price_of_floatingip_with_unit_price(self):
product = self.product_fixture.ip_products[0]
price_ref = self.query_price(product, 1)
hourly_price = pricing.calculate_price(1, product.unit_price)
self.assertDecimalEqual(hourly_price, price_ref['unit_price'])
price_ref = self.query_price(product, 10)
hourly_price = pricing.calculate_price(10, product.unit_price)
self.assertDecimalEqual(hourly_price, price_ref['unit_price'])
def test_get_price_of_floatingip_with_unit_price(self):
product = self.product_fixture.ip_products[0]
price_ref = self.query_price(product, 1)
hourly_price = pricing.calculate_price(1, product.unit_price)
self.assertDecimalEqual(hourly_price, price_ref['unit_price'])
price_ref = self.query_price(product, 10)
hourly_price = pricing.calculate_price(10, product.unit_price)
self.assertDecimalEqual(hourly_price, price_ref['unit_price'])
def process_notification(self, message, state=None):
payload = get_payload(message)
LOG.warn('Do action for event: %s, resource_id: %s',
message['event_type'], payload['id'])
self.send_email_notification(message)
# Generate uuid of an order
order_id = uuidutils.generate_uuid()
unit_price = 0
unit = 'hour'
# Create subscriptions for this order
for ext in self.product_items.extensions:
if ext.name.startswith('suspend'):
sub = ext.obj.create_subscription(message, order_id,
type=const.STATE_SUSPEND)
if sub and state == const.STATE_SUSPEND:
price_data = None
if 'extra' in sub and sub['extra']:
try:
extra_data = jsonutils.loads(sub['extra'])
price_data = extra_data.get('price', None)
except (Exception):
LOG.warning('Decode subscription["extra"] failed')
unit_price += pricing.calculate_price(
sub['quantity'], sub['unit_price'], price_data)
elif ext.name.startswith('running'):
sub = ext.obj.create_subscription(message, order_id,
type=const.STATE_RUNNING)
if sub and (not state or state == const.STATE_RUNNING):
price_data = None
if 'extra' in sub and sub['extra']:
try:
extra_data = jsonutils.loads(sub['extra'])
price_data = extra_data.get('price', None)
except (Exception):
LOG.warning('Decode subscription["extra"] failed')
unit_price += pricing.calculate_price(
sub['quantity'], sub['unit_price'], price_data)
# Create an order for this instance
self.create_order(order_id, unit_price, unit, message, state=state)
# Notify master, just give master messages it needs
remarks = 'Floating IP Has Been Created.'
action_time = message['timestamp']
if state:
self.resource_created_again(order_id, action_time, remarks)
else:
self.resource_created(order_id, action_time, remarks)
def process_notification(self, message, state=None):
payload = get_payload(message)
LOG.warn('Do action for event: %s, resource_id: %s',
message['event_type'], payload['id'])
self.send_email_notification(message)
# Generate uuid of an order
order_id = uuidutils.generate_uuid()
unit_price = 0
unit = 'hour'
# Create subscriptions for this order
for ext in self.product_items.extensions:
if ext.name.startswith('suspend'):
sub = ext.obj.create_subscription(message, order_id,
type=const.STATE_SUSPEND)
if sub and state == const.STATE_SUSPEND:
price_data = None
if 'extra' in sub and sub['extra']:
try:
extra_data = jsonutils.loads(sub['extra'])
price_data = extra_data.get('price', None)
except (Exception):
LOG.warning('Decode subscription["extra"] failed')
unit_price += pricing.calculate_price(
sub['quantity'], sub['unit_price'], price_data)
elif ext.name.startswith('running'):
sub = ext.obj.create_subscription(message, order_id,
type=const.STATE_RUNNING)
if sub and (not state or state == const.STATE_RUNNING):
price_data = None
if 'extra' in sub and sub['extra']:
try:
extra_data = jsonutils.loads(sub['extra'])
price_data = extra_data.get('price', None)
except (Exception):
LOG.warning('Decode subscription["extra"] failed')
unit_price += pricing.calculate_price(
sub['quantity'], sub['unit_price'], price_data)
# Create an order for this instance
self.create_order(order_id, unit_price, unit, message, state=state)
# Notify master, just give master messages it needs
remarks = 'Floating IP Has Been Created.'
action_time = message['timestamp']
if state:
self.resource_created_again(order_id, action_time, remarks)
else:
self.resource_created(order_id, action_time, remarks)
def test_get_price_of_two_products(self):
quantity = 1
product1 = self.product_fixture.instance_products[0]
product2 = self.product_fixture.instance_products[1]
price1 = pricing.calculate_price(quantity, product1.unit_price)
price2 = pricing.calculate_price(quantity, product2.unit_price)
purchase1 = self.build_purchase(
product1.name, product1.service, product1.region_id, quantity)
purchase2 = self.build_purchase(
product2.name, product2.service, product2.region_id, quantity)
query_url = self.build_price_query_url([purchase1, purchase2])
resp = self.get(query_url, headers=self.admin_headers)
price_ref = resp.json_body
self.assertDecimalEqual(price1 + price2, price_ref['unit_price'])
def test_get_price_of_two_products(self):
quantity = 1
product1 = self.product_fixture.instance_products[0]
product2 = self.product_fixture.instance_products[1]
price1 = pricing.calculate_price(quantity, product1.unit_price)
price2 = pricing.calculate_price(quantity, product2.unit_price)
purchase1 = self.build_purchase(product1.name, product1.service,
product1.region_id, quantity)
purchase2 = self.build_purchase(product2.name, product2.service,
product2.region_id, quantity)
query_url = self.build_price_query_url([purchase1, purchase2])
resp = self.get(query_url, headers=self.admin_headers)
price_ref = resp.json_body
self.assertDecimalEqual(price1 + price2, price_ref['unit_price'])
def _test_volume_create_unit_price(self, size, volume_type=None, is_segmented_price=False):
if is_segmented_price:
product = self._set_product_volume_to_segmented_price(volume_type)
extra = jsonutils.loads(product.extra)
price = pricing.calculate_price(size, product.unit_price, extra["price"])
else:
product = self._get_product_by_volume_type(volume_type)
price = pricing.calculate_price(size, product.unit_price)
resource_id = self._create_volume(volume_type, size, self.project_id)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
self.assertDecimalEqual(price, order.unit_price)
bill = self.dbconn.get_latest_bill(self.admin_req_context, order.order_id)
self.assertDecimalEqual(price, bill.unit_price)
def _test_volume_resize_end(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# original size
resource_id = self._create_volume(volume_type, self.size, self.project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
bill1 = self.dbconn.get_latest_bill(self.admin_req_context, order.order_id)
# change to new size
payload = self.build_volume_payload(volume_type, self.new_size, self.project_id, volume_id=resource_id)
message = self.build_notification_message(self.user_id, self.event_resized, payload, timestamp=end_time)
handle = volume.VolumeResizeEnd()
handle.process_notification(message)
price = pricing.calculate_price(self.new_size, product.unit_price)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(self.admin_req_context, order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(self.new_size, subs.quantity)
bill1 = self.dbconn.get_bill(self.admin_req_context, bill1.bill_id)
self.assertEqual(self.datetime_to_str(end_time), self.datetime_to_str(bill1.end_time))
bill2 = self.dbconn.get_latest_bill(self.admin_req_context, order.order_id)
self.assertEqual(self.datetime_to_str(end_time), self.datetime_to_str(bill2.start_time))
self.assertDecimalEqual(price, bill2.unit_price)
def get_unit_price(self, order_id, message):
"""Get unit price of this resource
As the resource has subscribed to the product, so we should
calculate price from the subscriptions instead of the product.
"""
c = self.get_collection(message)
product = self.gclient.get_product(c.product_name, c.service,
c.region_id)
if not product:
return 0
subs = self.gclient.get_subscriptions(order_id,
product_id=product['product_id'])
if subs:
sub = subs[0]
else:
LOG.warn("The order %s has no subscriptions" % order_id)
return 0
if 'extra' in sub:
price_data = pricing.get_price_data(sub['unit_price'])
else:
price_data = None
return pricing.calculate_price(c.resource_volume, price_data)
def _test_volume_create_end(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
price = pricing.calculate_price(self.size, product.unit_price)
start_time = self.utcnow()
resource_id = self._create_volume(volume_type,
self.size,
self.project_id,
timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(
self.dbconn.get_subscriptions_by_order_id(self.admin_req_context,
order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(gring_const.STATE_RUNNING, subs.type)
self.assertEqual(self.size, subs.quantity)
subs_product = self.dbconn.get_product(self.admin_req_context,
subs.product_id)
self.assertEqual(product.name, subs_product.name)
bill = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertEqual(resource_id, bill.resource_id)
self.assertEqual(self.datetime_to_str(start_time),
self.datetime_to_str(bill.start_time))
self.assertDecimalEqual(price, bill.unit_price)
def get_unit_price(self, order_id, message):
"""Get unit price of this resource
As the resource has subscribed to the product, so we should
calculate price from the subscriptions instead of the product.
"""
c = self.get_collection(message)
product = self.gclient.get_product(
c.product_name, c.service, c.region_id)
if not product:
return 0
subs = self.gclient.get_subscriptions(order_id,
product_id=product['product_id'])
if subs:
sub = subs[0]
else:
LOG.warn("The order %s has no subscriptions" % order_id)
return 0
if 'extra' in sub:
price_data = pricing.get_price_data(sub['unit_price'])
else:
price_data = None
return pricing.calculate_price(
c.resource_volume, price_data)
def _test_volume_change_unit_price_with_again_event(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# original size
resource_id = self._create_volume(volume_type, self.size, self.project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
# change to new size
expected_price = pricing.calculate_price(self.new_size, product.unit_price)
payload = self.build_volume_payload(volume_type, self.new_size, self.project_id, volume_id=resource_id)
vol = cinder.Volume(
id=payload["volume_id"],
name=payload["display_name"],
resource_type="volume",
size=payload["size"],
type=payload["volume_type"],
project_id=payload["tenant_id"],
user_id=payload["user_id"],
)
message = vol.to_message()
handle = volume.VolumeCreateEnd()
handle.change_unit_price(message, gring_const.STATE_RUNNING, order.order_id)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(expected_price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(self.admin_req_context, order.order_id))
for subs in subs_list:
self.assertEqual(self.new_size, subs.quantity)
def test_fipset_get_unit_price_with_again_event(self):
rate_limit = 10240
quantity = pricing.rate_limit_to_unit(rate_limit)
expected_price = pricing.calculate_price(
quantity, self.product.unit_price)
payload = self.build_floatingipset_payload(
self.fipset, rate_limit, self.admin_account.project_id)
payload = payload['floatingipset']
fipset = neutron.FloatingIpSet(
id=payload['id'], name=payload['uos:name'],
size=payload['rate_limit'], project_id=payload['tenant_id'],
providers=payload['uos:service_provider'],
resource_type=gring_const.RESOURCE_FLOATINGIPSET,
status=payload['status'], is_reserved=True)
message = fipset.to_message()
handle = floatingip.FloatingIpCreateEnd()
handle.process_notification(message)
resource_id = payload['id']
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
price = handle.get_unit_price(order.order_id,
message,
gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
def test_floatingip_create_end(self):
product = self.product_fixture.ip_products[0]
rate_limit = 1024
quantity = pricing.rate_limit_to_unit(rate_limit)
price = pricing.calculate_price(quantity, product.unit_price)
project_id = self.admin_account.project_id
start_time = self.utcnow()
resource_id = self.create_floatingip(
rate_limit, project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(
self.admin_req_context, order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(gring_const.STATE_RUNNING, subs.type)
self.assertEqual(quantity, subs.quantity)
bill = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertEqual(resource_id, bill.resource_id)
self.assertEqual(self.datetime_to_str(start_time),
self.datetime_to_str(bill.start_time))
self.assertDecimalEqual(price, bill.unit_price)
def test_floatingip_change_unit_price(self):
product = self.product_fixture.ip_products[0]
project_id = self.admin_account.project_id
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# rate_limit = 1024
rate_limit = 1024
resource_id = self.create_floatingip(
rate_limit, project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
# change rate_limit to 1024 * 11
rate_limit = 1024 * 11
quantity = pricing.rate_limit_to_unit(rate_limit)
expected_price = pricing.calculate_price(quantity, product.unit_price)
payload = self.build_floatingip_payload(
self.floating_ip_address, rate_limit, project_id, id=resource_id)
message = self.build_notification_message(
self.admin_account.user_id, self.event_resized, payload,
timestamp=end_time)
handle = floatingip.FloatingIpCreateEnd()
handle.change_unit_price(
message, gring_const.STATE_RUNNING, order.order_id)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(expected_price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(
self.admin_req_context, order.order_id))
for subs in subs_list:
self.assertEqual(quantity, subs.quantity)
def get_all(self, purchase):
"""Get price of a group of products."""
if purchase.bill_method not in ['hour', 'month', 'year']:
err = 'Should specify bill_method among hour, month and year'
raise exception.InvalidParameterValue(err=err)
if not isinstance(purchase.bill_period, int):
purchase.bill_period = 1
conn = pecan.request.db_conn
unit_price = quantize_decimal(0)
unit = purchase.bill_method
for p in purchase.purchases:
if all([p.product_id, p.quantity]):
try:
product = conn.get_product(request.context, p.product_id)
except exception.ProductIdNotFound:
LOG.warn("Product %s not found" % p.product_id)
raise
elif all([p.product_name, p.service, p.region_id, p.quantity]):
filters = dict(name=p.product_name,
service=p.service,
region_id=p.region_id)
products = list(conn.get_products(
request.context, filters=filters))
if len(products) == 0:
LOG.error('Product %s of region %s not found',
p.product_name, p.region_id)
raise exception.ProductNameNotFound(
product_name=p.product_name)
product = products[0]
else:
err = "Every purchase item should specify product_name, "\
"service, region_id and quantity or "\
"product_id and quantity."
raise exception.MissingRequiredParams(reason=err)
try:
if product.unit_price:
unit_price_data = jsonutils.loads(product.unit_price)
price_data = pricing.get_price_data(unit_price_data,
unit)
else:
price_data = None
unit_price += pricing.calculate_price(
p.quantity, price_data)
except (Exception) as e:
LOG.error('Calculate price of product %s failed, %s',
p.product_name, e)
raise e
total_price = unit_price * purchase.bill_period
return models.Price.transform(unit_price=unit_price,
unit=unit,
total_price=total_price)
def test_calculate_price_using_unit_price(self):
unit_price = '0.2'
quantity_list = [1, 2]
expected_list = ['0.2', '0.4']
for q, p in zip(quantity_list, expected_list):
price = pricing.calculate_price(q, unit_price)
self.assertEqual(self.quantize(p), price)
def _test_floatingip_created_unit_price(rate_limit):
price = pricing.calculate_price(
pricing.rate_limit_to_unit(rate_limit), product.unit_price)
resource_id = self.create_floatingip(rate_limit, project_id)
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
self.assertDecimalEqual(price, order.unit_price)
bill = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertDecimalEqual(price, bill.unit_price)
def get_all(self, purchase):
"""Get price of a group of products."""
if purchase.bill_method not in ['hour', 'month', 'year']:
err = 'Should specify bill_method among hour, month and year'
raise exception.InvalidParameterValue(err=err)
if not isinstance(purchase.bill_period, int):
purchase.bill_period = 1
conn = pecan.request.db_conn
unit_price = quantize_decimal(0)
unit = purchase.bill_method
for p in purchase.purchases:
if all([p.product_id, p.quantity]):
try:
product = conn.get_product(request.context, p.product_id)
except exception.ProductIdNotFound:
LOG.warn("Product %s not found" % p.product_id)
raise
elif all([p.product_name, p.service, p.region_id, p.quantity]):
filters = dict(name=p.product_name,
service=p.service,
region_id=p.region_id)
products = list(
conn.get_products(request.context, filters=filters))
if len(products) == 0:
LOG.error('Product %s of region %s not found',
p.product_name, p.region_id)
raise exception.ProductNameNotFound(
product_name=p.product_name)
product = products[0]
else:
err = "Every purchase item should specify product_name, "\
"service, region_id and quantity or "\
"product_id and quantity."
raise exception.MissingRequiredParams(reason=err)
try:
if product.unit_price:
unit_price_data = jsonutils.loads(product.unit_price)
price_data = pricing.get_price_data(unit_price_data, unit)
else:
price_data = None
unit_price += pricing.calculate_price(p.quantity, price_data)
except (Exception) as e:
LOG.error('Calculate price of product %s failed, %s',
p.product_name, e)
raise e
total_price = unit_price * purchase.bill_period
return models.Price.transform(unit_price=unit_price,
unit=unit,
total_price=total_price)
def test_calculate_price_using_base_price_and_segmented_price(self):
unit_price = '0.2'
price_data = test_utils.PricingTestMixin.build_segmented_price_data(
'5.0', [[10, '0.1'], [4, '0.2'], [0, '0.3']])
quantity_list = [1, 4, 5, 10, 11]
expected_list = ['5.3', '6.2', '6.4', '7.4', '7.5']
for q, p in zip(quantity_list, expected_list):
price = pricing.calculate_price(q, unit_price, price_data)
self.assertEqual(self.quantize(p), price)
def _test_volume_create_unit_price(self,
size,
volume_type=None,
is_segmented_price=False):
if is_segmented_price:
product = self._set_product_volume_to_segmented_price(volume_type)
extra = jsonutils.loads(product.extra)
price = pricing.calculate_price(size, product.unit_price,
extra['price'])
else:
product = self._get_product_by_volume_type(volume_type)
price = pricing.calculate_price(size, product.unit_price)
resource_id = self._create_volume(volume_type, size, self.project_id)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
self.assertDecimalEqual(price, order.unit_price)
bill = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertDecimalEqual(price, bill.unit_price)
def _test_volume_get_unit_price(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
expected_price = pricing.calculate_price(self.size, product.unit_price)
payload = self.build_volume_payload(volume_type, self.size, self.project_id)
message = self.build_notification_message(self.user_id, self.event_created, payload)
handle = volume.VolumeCreateEnd()
handle.process_notification(message)
resource_id = payload["volume_id"]
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
price = handle.get_unit_price(order.order_id, message, gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
def get_unit_price(self, env, body, method):
"""Get product unit price"""
collection = self.get_collection(env, body)
product = self.gclient.get_product(collection.product_name,
collection.service,
collection.region_id)
if product:
if 'extra' in product:
price_data = pricing.get_price_data(product['extra'], method)
else:
price_data = None
return pricing.calculate_price(
collection.resource_volume, product['unit_price'], price_data)
else:
return 0
def test_get_price_of_product_with_nonzero_index(self):
product = self.product_fixture.ip_products[0]
quantity = 1
purchase = self.build_purchase(
product.name, product.service, product.region_id, quantity)
price = pricing.calculate_price(quantity, product.unit_price)
query_vars = ['purchase.bill_method=hour']
for k, v in six.iteritems(purchase):
query_vars.append('purchase.purchases[1].%s=%s' % (k, v))
query_parts = '&'.join(query_vars)
LOG.debug(query_parts)
query_url = self.price_path + '?' + query_parts
resp = self.get(query_url, headers=self.admin_headers)
price_ref = resp.json_body
LOG.debug(price_ref)
self.assertDecimalEqual(price, price_ref['unit_price'])
def _test_volume_resize_end(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# original size
resource_id = self._create_volume(volume_type,
self.size,
self.project_id,
timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
bill1 = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
# change to new size
payload = self.build_volume_payload(volume_type,
self.new_size,
self.project_id,
volume_id=resource_id)
message = self.build_notification_message(self.user_id,
self.event_resized,
payload,
timestamp=end_time)
handle = volume.VolumeResizeEnd()
handle.process_notification(message)
price = pricing.calculate_price(self.new_size, product.unit_price)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(
self.dbconn.get_subscriptions_by_order_id(self.admin_req_context,
order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(self.new_size, subs.quantity)
bill1 = self.dbconn.get_bill(self.admin_req_context, bill1.bill_id)
self.assertEqual(self.datetime_to_str(end_time),
self.datetime_to_str(bill1.end_time))
bill2 = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertEqual(self.datetime_to_str(end_time),
self.datetime_to_str(bill2.start_time))
self.assertDecimalEqual(price, bill2.unit_price)
def test_get_price_of_product_with_nonzero_index(self):
product = self.product_fixture.ip_products[0]
quantity = 1
purchase = self.build_purchase(product.name, product.service,
product.region_id, quantity)
price = pricing.calculate_price(quantity, product.unit_price)
query_vars = ['purchase.bill_method=hour']
for k, v in six.iteritems(purchase):
query_vars.append('purchase.purchases[1].%s=%s' % (k, v))
query_parts = '&'.join(query_vars)
LOG.debug(query_parts)
query_url = self.price_path + '?' + query_parts
resp = self.get(query_url, headers=self.admin_headers)
price_ref = resp.json_body
LOG.debug(price_ref)
self.assertDecimalEqual(price, price_ref['unit_price'])
def get_unit_price(self, env, body, method):
"""Get product unit price"""
collection = self.get_collection(env, body)
product = self.gclient.get_product(collection.product_name,
collection.service,
collection.region_id)
if product:
if 'unit_price' in product:
price_data = pricing.get_price_data(product['unit_price'],
method)
else:
price_data = None
return pricing.calculate_price(collection.resource_volume,
price_data)
else:
return 0
def _test_volume_get_unit_price(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
expected_price = pricing.calculate_price(self.size, product.unit_price)
payload = self.build_volume_payload(volume_type, self.size,
self.project_id)
message = self.build_notification_message(self.user_id,
self.event_created, payload)
handle = volume.VolumeCreateEnd()
handle.process_notification(message)
resource_id = payload['volume_id']
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
price = handle.get_unit_price(order.order_id, message,
gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
def test_floatingip_resize_end(self):
product = self.product_fixture.ip_products[0]
project_id = self.admin_account.project_id
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# rate_limit = 1024
rate_limit = 1024
resource_id = self.create_floatingip(
rate_limit, project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
bill1 = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
# change rate_limit to 1024 * 11
rate_limit = 1024 * 11
quantity = pricing.rate_limit_to_unit(rate_limit)
payload = self.build_floatingip_payload(
self.floating_ip_address, rate_limit, project_id, id=resource_id)
message = self.build_notification_message(
self.admin_account.user_id, self.event_resized, payload,
timestamp=end_time)
handle = floatingip.FloatingIpResizeEnd()
handle.process_notification(message)
price = pricing.calculate_price(quantity, product.unit_price)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(
self.admin_req_context, order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(quantity, subs.quantity)
bill1 = self.dbconn.get_bill(self.admin_req_context, bill1.bill_id)
self.assertEqual(self.datetime_to_str(end_time),
self.datetime_to_str(bill1.end_time))
bill2 = self.dbconn.get_latest_bill(self.admin_req_context,
order.order_id)
self.assertEqual(self.datetime_to_str(end_time),
self.datetime_to_str(bill2.start_time))
self.assertDecimalEqual(price, bill2.unit_price)
def _test_volume_change_unit_price_with_again_event(
self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# original size
resource_id = self._create_volume(volume_type,
self.size,
self.project_id,
timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
# change to new size
expected_price = pricing.calculate_price(self.new_size,
product.unit_price)
payload = self.build_volume_payload(volume_type,
self.new_size,
self.project_id,
volume_id=resource_id)
vol = cinder.Volume(id=payload['volume_id'],
name=payload['display_name'],
resource_type='volume',
size=payload['size'],
type=payload['volume_type'],
project_id=payload['tenant_id'],
user_id=payload['user_id'])
message = vol.to_message()
handle = volume.VolumeCreateEnd()
handle.change_unit_price(message, gring_const.STATE_RUNNING,
order.order_id)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(expected_price, order.unit_price)
subs_list = list(
self.dbconn.get_subscriptions_by_order_id(self.admin_req_context,
order.order_id))
for subs in subs_list:
self.assertEqual(self.new_size, subs.quantity)
def test_update_product_with_segmented_price_and_reset(self):
product = self.product_fixture.ip_products[0]
quantity = 11
resource_type = gring_const.RESOURCE_FLOATINGIP
order_id = self.new_order_id()
user_id = self.admin_account.user_id
project_id = self.admin_account.project_id
running_subs = self.create_subs_in_db(product, quantity,
gring_const.STATE_RUNNING,
order_id, project_id, user_id)
order = self.create_order_in_db(running_subs.unit_price,
running_subs.unit,
user_id,
project_id,
resource_type,
running_subs.type,
order_id=order_id)
price_data = self.build_segmented_price_data(
'0.0000', [[10, '0.1'], [4, '0.2'], [0, '0.3']])
extra = {'price': price_data}
body = {
'extra': jsonutils.dumps(extra),
'reset': True,
}
query_url = self.build_product_query_url(product.product_id)
self.put(query_url,
headers=self.admin_headers,
body=body,
expected_status=200)
expected_price = pricing.calculate_price(quantity, product.unit_price,
price_data)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
subs = list(
self.dbconn.get_subscriptions_by_order_id(self.admin_req_context,
order.order_id))
for sub in subs:
self.assertEqual(extra, jsonutils.loads(sub.extra))
self.assertDecimalEqual(expected_price, order.unit_price)
def _test_volume_create_end(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
price = pricing.calculate_price(self.size, product.unit_price)
start_time = self.utcnow()
resource_id = self._create_volume(volume_type, self.size, self.project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
self.assertDecimalEqual(price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(self.admin_req_context, order.order_id))
self.assertEqual(1, len(subs_list))
for subs in subs_list:
self.assertEqual(gring_const.STATE_RUNNING, subs.type)
self.assertEqual(self.size, subs.quantity)
subs_product = self.dbconn.get_product(self.admin_req_context, subs.product_id)
self.assertEqual(product.name, subs_product.name)
bill = self.dbconn.get_latest_bill(self.admin_req_context, order.order_id)
self.assertEqual(resource_id, bill.resource_id)
self.assertEqual(self.datetime_to_str(start_time), self.datetime_to_str(bill.start_time))
self.assertDecimalEqual(price, bill.unit_price)
def test_fipset_change_unit_price_with_again_event(self):
project_id = self.admin_account.project_id
end_time = self.utcnow()
start_time = end_time - datetime.timedelta(hours=1)
# rate_limit = 1024
rate_limit = 1024
resource_id = self.create_floatingipset(
rate_limit, project_id, timestamp=start_time)
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
# change rate_limit to 1024 * 11
rate_limit = 1024 * 11
quantity = pricing.rate_limit_to_unit(rate_limit)
expected_price = pricing.calculate_price(
quantity, self.product.unit_price)
payload = self.build_floatingipset_payload(
self.fipset, rate_limit, self.admin_account.project_id)
payload = payload['floatingipset']
fipset = neutron.FloatingIpSet(
id=payload['id'], name=payload['uos:name'],
size=payload['rate_limit'], project_id=payload['tenant_id'],
providers=payload['uos:service_provider'],
resource_type=gring_const.RESOURCE_FLOATINGIPSET,
status=payload['status'], is_reserved=True)
message = fipset.to_message()
handle = floatingip.FloatingIpCreateEnd()
handle.change_unit_price(
message, gring_const.STATE_RUNNING, order.order_id)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
self.assertDecimalEqual(expected_price, order.unit_price)
subs_list = list(self.dbconn.get_subscriptions_by_order_id(
self.admin_req_context, order.order_id))
for subs in subs_list:
self.assertEqual(quantity, subs.quantity)
def _test_volume_get_unit_price_with_again_event(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
expected_price = pricing.calculate_price(self.size, product.unit_price)
payload = self.build_volume_payload(volume_type, self.size, self.project_id)
vol = cinder.Volume(
id=payload["volume_id"],
name=payload["display_name"],
resource_type="volume",
size=payload["size"],
type=payload["volume_type"],
project_id=payload["tenant_id"],
user_id=payload["user_id"],
)
message = vol.to_message()
handle = volume.VolumeCreateEnd()
handle.process_notification(message)
resource_id = payload["volume_id"]
order = self.dbconn.get_order_by_resource_id(self.admin_req_context, resource_id)
price = handle.get_unit_price(order.order_id, message, gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
def test_floatingip_get_unit_price(self):
product = self.product_fixture.ip_products[0]
rate_limit = 10240
quantity = pricing.rate_limit_to_unit(rate_limit)
expected_price = pricing.calculate_price(quantity, product.unit_price)
payload = self.build_floatingip_payload(
self.floating_ip_address, rate_limit,
self.admin_account.project_id)
message = self.build_notification_message(
self.admin_account.user_id, self.event_created, payload)
handle = floatingip.FloatingIpCreateEnd()
handle.process_notification(message)
resource_id = payload['floatingip']['id']
order = self.dbconn.get_order_by_resource_id(
self.admin_req_context, resource_id)
price = handle.get_unit_price(order.order_id,
message,
gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
def test_update_product_with_segmented_price_and_reset(self):
product = self.product_fixture.ip_products[0]
quantity = 11
resource_type = gring_const.RESOURCE_FLOATINGIP
order_id = self.new_order_id()
user_id = self.admin_account.user_id
project_id = self.admin_account.project_id
running_subs = self.create_subs_in_db(
product, quantity, gring_const.STATE_RUNNING,
order_id, project_id, user_id
)
order = self.create_order_in_db(
running_subs.unit_price, running_subs.unit,
user_id, project_id, resource_type,
running_subs.type, order_id=order_id
)
price_data = self.build_segmented_price_data(
'0.0000', [[10, '0.1'], [4, '0.2'], [0, '0.3']])
extra = {'price': price_data}
body = {
'extra': jsonutils.dumps(extra),
'reset': True,
}
query_url = self.build_product_query_url(product.product_id)
self.put(query_url, headers=self.admin_headers,
body=body, expected_status=200)
expected_price = pricing.calculate_price(
quantity, product.unit_price, price_data)
order = self.dbconn.get_order(self.admin_req_context, order.order_id)
subs = list(self.dbconn.get_subscriptions_by_order_id(
self.admin_req_context, order.order_id))
for sub in subs:
self.assertEqual(extra, jsonutils.loads(sub.extra))
self.assertDecimalEqual(expected_price, order.unit_price)
def _test_volume_get_unit_price_with_again_event(self, volume_type=None):
product = self._get_product_by_volume_type(volume_type)
expected_price = pricing.calculate_price(self.size, product.unit_price)
payload = self.build_volume_payload(volume_type, self.size,
self.project_id)
vol = cinder.Volume(id=payload['volume_id'],
name=payload['display_name'],
resource_type='volume',
size=payload['size'],
type=payload['volume_type'],
project_id=payload['tenant_id'],
user_id=payload['user_id'])
message = vol.to_message()
handle = volume.VolumeCreateEnd()
handle.process_notification(message)
resource_id = payload['volume_id']
order = self.dbconn.get_order_by_resource_id(self.admin_req_context,
resource_id)
price = handle.get_unit_price(order.order_id, message,
gring_const.STATE_RUNNING)
self.assertDecimalEqual(expected_price, price)
