def test_two_ranges(self):
number1 = value_factory({
"type": "numeric::step",
"name": "actual sheet thickness",
"description":
"The actual thickness of the sheet to the nearest 0.1 mm",
"max": Decimal("18"),
"min": Decimal("16.5"),
"start": Decimal("16.5"),
"step": Decimal("0.1")
})
number2 = value_factory({
"scopes": ["making"],
"type": "numeric::step",
"name": "actual sheet thickness",
"description":
"The actual thickness of the sheet to the nearest 0.1 mm",
"max": Decimal("19"),
"min": Decimal("17.5"),
"start": Decimal("17.5"),
"step": Decimal("0.1")
})
number3 = number2.intersection(number1)
print number3
self.assertTrue(number3 != None)
def test_convienence_methods_single_values(self):
b = value_factory(True)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], True)
b = value_factory(False)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], False)
b = value_factory([False, True])
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], list))
self.assertEqual(value[u"value"], [True, False])
def test_options_creation(self):
NULL_STRING = {
u"type": VALUE_TYPE_SET_NULL,
u"options": {
u"eat": [u"fish", u"chips"]
}
}
null_option = value_factory(NULL_STRING)
string_option = value_factory([u"red", u"green"])
self.assertTrue(string_option.issubset(null_option))
intersection = string_option.intersection(null_option)
expected = [{
'type': u'string',
'value': u'green'
}, {
'type': u'string',
'value': u'red'
}]
self.assertEqual(expected, intersection.as_json())
self.assertTrue(string_option.isdisjoint(null_option) is False)
def test_two_ranges(self):
number1 = value_factory({
"type": "numeric::step",
"name": "actual sheet thickness",
"description": "The actual thickness of the sheet to the nearest 0.1 mm",
"max": Decimal("18"),
"min": Decimal("16.5"),
"start": Decimal("16.5"),
"step": Decimal("0.1")
})
number2 = value_factory({
"scopes": ["making"],
"type": "numeric::step",
"name": "actual sheet thickness",
"description": "The actual thickness of the sheet to the nearest 0.1 mm",
"max": Decimal("19"),
"min": Decimal("17.5"),
"start": Decimal("17.5"),
"step": Decimal("0.1")
})
number3 = number2.intersection(number1)
print number3
self.assertTrue(number3 != None)
def test_convienence_methods_single_values(self):
number = value_factory(2)
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], int))
self.assertEqual(value[u"value"], 2)
number = value_factory(2.2)
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 2.2)
number = value_factory(Decimal(2.2))
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 2.2)
def test_convienence_methods_lists(self):
number = value_factory([2])
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertEqual(value[u"value"], 2)
number = value_factory([2.2, 3.8])
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertEqual(value[u"value"], [2.2, 3.8])
number = value_factory([2, 3.8, "5"])
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertEqual(value[u"value"], [2, 3.8, 5])
self.assertRaises(OptionsExceptionFailedValidation, value_factory,
[2, 3.8, "poo"])
def test_convienence_methods_single_values(self):
b = value_factory(True)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], True)
b = value_factory(False)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], False)
b = value_factory([False, True])
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], list))
self.assertEqual(value[u"value"], [True, False])
def test_convienence_methods_lists(self):
number = value_factory([2])
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertEqual(value[u"value"], 2)
number = value_factory([2.2, 3.8])
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertEqual(value[u"value"], [2.2, 3.8])
number = value_factory([2, 3.8, "5"])
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertEqual(value[u"value"], [2, 3.8, 5])
self.assertRaises(OptionsExceptionFailedValidation, value_factory, [2, 3.8, "poo"])
def test_creation(self):
doc = {"type": "boolean", "value": True}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], True)
doc = {"type": "boolean", "value": False}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], False)
doc = {"type": "boolean", "value": [False, True]}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], list))
self.assertEqual(value[u"value"], [True, False])
def test_convienence_methods_single_values(self):
number = value_factory(2)
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], int))
self.assertEqual(value[u"value"], 2)
number = value_factory(2.2)
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 2.2)
number = value_factory(Decimal(2.2))
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(number.number, Decimal))
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 2.2)
def test_logic(self):
null_option = value_factory(None)
string_option = value_factory([u"red", u"blue"])
self.assertTrue(string_option.issubset(null_option))
self.assertTrue(string_option.intersection(null_option) == string_option)
self.assertTrue(string_option.isdisjoint(null_option) is False)
def test_logic(self):
null_option = value_factory(None)
string_option = value_factory([u"red", u"blue"])
self.assertTrue(string_option.issubset(null_option))
self.assertTrue(
string_option.intersection(null_option) == string_option)
self.assertTrue(string_option.isdisjoint(null_option) is False)
def test_intersection(self):
t = value_factory(True)
f = value_factory(False)
n = value_factory([False, True])
n2 = value_factory([True, False])
self.assertEqual(t.intersection(n).true, True)
self.assertEqual(t.intersection(f), None)
self.assertEqual(f.intersection(t), None)
self.assertEqual(f.intersection(n).true, False)
self.assertEqual(n.intersection(n2).true, None)
def test_intersection(self):
t = value_factory(True)
f = value_factory(False)
n = value_factory([False, True])
n2 = value_factory([True, False])
self.assertEqual(t.intersection(n).true, True)
self.assertEqual(t.intersection(f), None)
self.assertEqual(f.intersection(t), None)
self.assertEqual(f.intersection(n).true, False)
self.assertEqual(n.intersection(n2).true, None)
def test_disjoint(self):
t = value_factory(True)
f = value_factory(False)
n = value_factory([False, True])
n2 = value_factory([True, False])
self.assertFalse(t.isdisjoint(n))
self.assertFalse(f.isdisjoint(n))
self.assertFalse(n2.isdisjoint(n))
self.assertFalse(n.isdisjoint(t))
self.assertFalse(n.isdisjoint(f))
self.assertTrue(t.isdisjoint(f))
self.assertTrue(f.isdisjoint(t))
def test_is_subset(self):
number1 = value_factory(2)
number2 = value_factory(2)
self.assertTrue(number1.issubset(number2))
number3 = value_factory([2, 4])
self.assertTrue(number1.issubset(number3))
self.assertFalse(number3.issubset(number1))
number4 = value_factory([4, 8])
number5 = value_factory([4, 8])
self.assertFalse(number3.issubset(number4))
self.assertFalse(number4.issubset(number3))
self.assertTrue(number4.issubset(number5))
number6 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("8"),
"min": Decimal("4"),
})
number7 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("2"),
})
number8 = value_factory(7)
self.assertTrue(number4.issubset(number6))
self.assertTrue(number6.issubset(number4))
self.assertTrue(number4.issubset(number7))
self.assertFalse(number7.issubset(number4))
self.assertTrue(number8.issubset(number7))
self.assertFalse(number7.issubset(number8))
number9 = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": Decimal("9"),
"min": Decimal("2"),
"start": Decimal("2"),
"step": Decimal("3"),
})
self.assertTrue(number1.issubset(number9))
self.assertFalse(number3.issubset(number9))
self.assertTrue(number9.issubset(number7))
self.assertFalse(number7.issubset(number9))
def test_is_subset(self):
number1 = value_factory(2)
number2 = value_factory(2)
self.assertTrue(number1.issubset(number2))
number3 = value_factory([2, 4])
self.assertTrue(number1.issubset(number3))
self.assertFalse(number3.issubset(number1))
number4 = value_factory([4, 8])
number5 = value_factory([4, 8])
self.assertFalse(number3.issubset(number4))
self.assertFalse(number4.issubset(number3))
self.assertTrue(number4.issubset(number5))
number6 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("8"),
"min": Decimal("4"),
})
number7 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("2"),
})
number8 = value_factory(7)
self.assertTrue(number4.issubset(number6))
self.assertTrue(number6.issubset(number4))
self.assertTrue(number4.issubset(number7))
self.assertFalse(number7.issubset(number4))
self.assertTrue(number8.issubset(number7))
self.assertFalse(number7.issubset(number8))
number9 = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": Decimal("9"),
"min": Decimal("2"),
"start": Decimal("2"),
"step": Decimal("3"),
})
self.assertTrue(number1.issubset(number9))
self.assertFalse(number3.issubset(number9))
self.assertTrue(number9.issubset(number7))
self.assertFalse(number7.issubset(number9))
def test_subset(self):
t = value_factory(True)
f = value_factory(False)
n = value_factory([False, True])
n2 = value_factory([True, False])
self.assertTrue(t.issubset(n))
self.assertTrue(f.issubset(n))
self.assertTrue(n2.issubset(n))
self.assertFalse(n.issubset(t))
self.assertFalse(n.issubset(f))
self.assertFalse(t.issubset(f))
self.assertFalse(f.issubset(t))
def test_create_from_dict_full(self):
option = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
self.assertTrue(isinstance(option, OptionStringWinnowValue))
values = option.values
print values
def test_create_from_dict_full(self):
option = value_factory({
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
},
{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
})
self.assertTrue(isinstance(option, OptionStringWinnowValue))
values = option.values
print values
def test_intersection_2(self):
## if have no options just copies
NESTED_OPTIONS_STRING_4 = {
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
}
option1 = value_factory(NESTED_OPTIONS_STRING)
option4 = value_factory(NESTED_OPTIONS_STRING_4)
intersection = option1.intersection(option4)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"]
[u"max"] == Decimal(6))
## the other way round
intersection = option4.intersection(option1)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"]
[u"max"] == Decimal(6))
def test_convienence_methods_single_values(self):
option = value_factory(u"red")
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertEqual(d, u"red")
def test_convienence_methods_single_values(self):
option = value_factory(u"red")
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertEqual(d, u"red")
def test_convienence_methods_none(self):
option = value_factory(None)
d = option.as_json()
self.assertTrue(isinstance(option, OptionNullWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_NULL)
print d
self.assertTrue(d is None)
def test_convienence_methods_none(self):
option = value_factory(None)
d = option.as_json()
self.assertTrue(isinstance(option, OptionNullWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_NULL)
print d
self.assertTrue(d is None)
def test_isdisjoint(self):
number1 = value_factory(2)
number2 = value_factory(2)
number3 = value_factory([2, 4])
number4 = value_factory([4, 8])
self.assertFalse(number1.isdisjoint(number2))
self.assertFalse(number1.isdisjoint(number3))
self.assertTrue(number1.isdisjoint(number4))
number6 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("8"),
"min": Decimal("4"),
})
number7 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("2"),
})
number8 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("9"),
})
self.assertTrue(number6.isdisjoint(number8))
def test_isdisjoint(self):
number1 = value_factory(2)
number2 = value_factory(2)
number3 = value_factory([2, 4])
number4 = value_factory([4, 8])
self.assertFalse(number1.isdisjoint(number2))
self.assertFalse(number1.isdisjoint(number3))
self.assertTrue(number1.isdisjoint(number4))
number6 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("8"),
"min": Decimal("4"),
})
number7 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("2"),
})
number8 = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("10"),
"min": Decimal("9"),
})
self.assertTrue(number6.isdisjoint(number8))
def test_create_set(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2"), Decimal("17.4")]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertTrue(isinstance(value[u"value"][0], int))
self.assertEqual(value[u"value"], [2, 17.4])
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2"), 17.4]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertTrue(isinstance(value[u"value"][0], int))
self.assertEqual(value[u"value"], [2, 17.4])
# casts down
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2")]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2)
def test_intersection_2(self):
## if have no options just copies
NESTED_OPTIONS_STRING_4 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
option1 = value_factory(NESTED_OPTIONS_STRING)
option4 = value_factory(NESTED_OPTIONS_STRING_4)
intersection = option1.intersection(option4)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"][u"max"] == Decimal(6))
## the other way round
intersection = option4.intersection(option1)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"][u"max"] == Decimal(6))
def test_create_range(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("21.5"),
"min": Decimal("13.4"),
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericRangeWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_RANGE)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertEqual(number.max, Decimal("21.5"))
self.assertEqual(number.min, Decimal("13.4"))
number = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": 21.5,
"min": 13.4,
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericRangeWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_RANGE)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertEqual(number.max, Decimal("21.5"))
self.assertEqual(number.min, Decimal("13.4"))
def test_convienence_methods_lists(self):
option = value_factory([u"red", u"blue"])
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, [u"blue", u"red"])
values = option.values
self.assertTrue(isinstance(values, list))
self.assertEqual(len(values), 2)
self.assertTrue(isinstance(values[0], unicode))
option = value_factory([u"red"])
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, u"red")
def test_create_set(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2"), Decimal("17.4")]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertTrue(isinstance(value[u"value"][0], int))
self.assertEqual(value[u"value"], [2, 17.4])
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2"), 17.4]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericSetWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_SET)
self.assertTrue(isinstance(value[u"value"], list))
self.assertTrue(isinstance(number.as_list[0], Decimal))
self.assertTrue(isinstance(value[u"value"][0], int))
self.assertEqual(value[u"value"], [2, 17.4])
# casts down
number = value_factory({
"type": VALUE_TYPE_NUMERIC_SET,
"value": [Decimal("2")]
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2)
def test_convienence_methods_lists(self):
option = value_factory([u"red", u"blue"])
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, [u"blue", u"red"])
values = option.values
self.assertTrue(isinstance(values, list))
self.assertEqual(len(values), 2)
self.assertTrue(isinstance(values[0], unicode))
option = value_factory([u"red"])
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, u"red")
def test_create_step(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": 21.5,
"min": 13.4,
"start": 13.4,
"step": 3.0,
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericStepWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_STEP)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertTrue(isinstance(value[u"step"], int))
self.assertTrue(isinstance(value[u"start"], float))
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertTrue(isinstance(number.step, Decimal))
self.assertTrue(isinstance(number.start, Decimal))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertEqual(number.possible_values(),
{Decimal("13.4"),
Decimal("16.4"),
Decimal("19.4")})
# casts down
number = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": Decimal("21.5"),
"min": Decimal("13.4"),
"start": Decimal("13.4"),
"step": Decimal("10.0"),
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 13.4)
def test_options_creation(self):
NULL_STRING = {
u"type": VALUE_TYPE_SET_NULL,
u"options": {
u"eat": [u"fish", u"chips"]
}
}
null_option = value_factory(NULL_STRING)
string_option = value_factory([u"red", u"green"])
self.assertTrue(string_option.issubset(null_option))
intersection = string_option.intersection(null_option)
expected = [{'type': u'string', 'value': u'green'}, {'type': u'string', 'value': u'red'}]
self.assertEqual(expected, intersection.as_json())
self.assertTrue(string_option.isdisjoint(null_option) is False)
def test_create_proper_string_single(self):
option = value_factory(NESTED_OPTIONS_STRING)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(len(option), 2)
def test_create_proper_string_single(self):
option = value_factory(NESTED_OPTIONS_STRING)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(len(option), 2)
def doit(max):
v1 = {
'name': u'Quantity',
'min': 1,
'default': 1,
'max': max,
'start': 0,
'step': 1,
'type': u'numeric::step'
}
v2 = 1
A = value_factory(v1)
B = value_factory(v2)
t1 = time.time()
intersection = A.intersection(B)
t2 = time.time()
return (t2 - t1)
def doit(max):
v1 = {
'name': u'Quantity',
'min': 1,
'default': 1,
'max': max,
'start': 0,
'step': 1,
'type': u'numeric::step'
}
v2 = 1
A = value_factory(v1)
B = value_factory(v2)
t1 = time.time()
intersection = A.intersection(B)
t2 = time.time()
return (t2 - t1)
def test_create_numbers(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_NUMBER,
"value": 2.2
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2.2)
number = value_factory({
"type": VALUE_TYPE_NUMERIC_NUMBER,
"value": 2
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2)
number = value_factory({
"type": VALUE_TYPE_NUMERIC_NUMBER,
"value": Decimal("2.2")
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2.2)
def test_create_range(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": Decimal("21.5"),
"min": Decimal("13.4"),
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericRangeWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_RANGE)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertEqual(number.max, Decimal("21.5"))
self.assertEqual(number.min, Decimal("13.4"))
number = value_factory({
"type": VALUE_TYPE_NUMERIC_RANGE,
"max": 21.5,
"min": 13.4,
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericRangeWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_RANGE)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertEqual(number.max, Decimal("21.5"))
self.assertEqual(number.min, Decimal("13.4"))
def doit(max):
v = {
'name': u'Quantity',
'min': 1,
'default': 1,
'max': max,
'type': u'numeric::range'
}
t1 = time.time()
d = value_factory(v).default
t2 = time.time()
return (t2 - t1)
def test_create_proper_string_proper_list(self):
option = value_factory(BASIC_STRING)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], list))
self.assertTrue(isinstance(d[VALUES_KEY_NAME][0], dict))
self.assertEqual(d[VALUES_KEY_NAME][1]["value"], u"red")
def test_create_proper_string_proper_list(self):
option = value_factory(BASIC_STRING)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], list))
self.assertTrue(isinstance(d[VALUES_KEY_NAME][0], dict))
self.assertEqual(d[VALUES_KEY_NAME][1]["value"], u"red")
def doit(max):
v = {
'name': u'Quantity',
'min': 1,
'default': 1,
'max': max,
'type': u'numeric::range'
}
t1 = time.time()
d = value_factory(v).default
t2 = time.time()
return (t2 - t1)
def test_creation(self):
doc = {
"type": "boolean",
"value": True
}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], True)
doc = {
"type": "boolean",
"value": False
}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], bool))
self.assertEqual(value[u"value"], False)
doc = {
"type": "boolean",
"value": [False, True]
}
b = value_factory(doc)
value = b.as_json()
self.assertTrue(isinstance(b, BooleanWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_BOOLEAN)
self.assertTrue(isinstance(value[u"value"], list))
self.assertEqual(value[u"value"], [True, False])
def test_create_step(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": 21.5,
"min": 13.4,
"start": 13.4,
"step": 3.0,
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericStepWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_STEP)
self.assertTrue(isinstance(value[u"max"], float))
self.assertTrue(isinstance(value[u"min"], float))
self.assertTrue(isinstance(value[u"step"], int))
self.assertTrue(isinstance(value[u"start"], float))
self.assertTrue(isinstance(number.max, Decimal))
self.assertTrue(isinstance(number.min, Decimal))
self.assertTrue(isinstance(number.step, Decimal))
self.assertTrue(isinstance(number.start, Decimal))
self.assertEqual(value[u"max"], 21.5)
self.assertEqual(value[u"min"], 13.4)
self.assertEqual(number.possible_values(), {Decimal("13.4"), Decimal("16.4"), Decimal("19.4")})
# casts down
number = value_factory({
"type": VALUE_TYPE_NUMERIC_STEP,
"max": Decimal("21.5"),
"min": Decimal("13.4"),
"start": Decimal("13.4"),
"step": Decimal("10.0"),
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertEqual(value[u"value"], 13.4)
def default(self):
options = {}
for k, v in self.store.iteritems():
value = value_factory(v)
options[k] = value.default
if isinstance(value, OptionWinnowValue):
child_options = value.get_default_value_options()
if child_options is not None:
childSet = OptionsSet(child_options)
child_defaults = childSet.default().store
for ck, cv in child_defaults.iteritems():
path = "{}/{}".format(k, ck)
options[path] = cv
return OptionsSet(options)
def default(self):
options = {}
for k, v in self.store.iteritems():
value = value_factory(v)
options[k] = value.default
if isinstance(value, OptionWinnowValue):
child_options = value.get_default_value_options()
if child_options is not None:
childSet = OptionsSet(child_options)
child_defaults = childSet.default().store
for ck, cv in child_defaults.iteritems():
path = "{}/{}".format(k, ck)
options[path] = cv
return OptionsSet(options)
def test_create_numbers(self):
number = value_factory({
"type": VALUE_TYPE_NUMERIC_NUMBER,
"value": 2.2
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2.2)
number = value_factory({"type": VALUE_TYPE_NUMERIC_NUMBER, "value": 2})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], int))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2)
number = value_factory({
"type": VALUE_TYPE_NUMERIC_NUMBER,
"value": Decimal("2.2")
})
value = number.as_json()
self.assertTrue(isinstance(number, NumericNumberWinnowValue))
self.assertEqual(value[u"type"], VALUE_TYPE_NUMERIC_NUMBER)
self.assertTrue(isinstance(value[u"value"], float))
self.assertTrue(isinstance(number.number, Decimal))
self.assertEqual(value[u"value"], 2.2)
def test_create_proper_string_single(self):
option = value_factory({
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red", ## optional??
VALUES_KEY_NAME: u"red"
})
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(d[VALUES_KEY_NAME], u"red")
def test_create_proper_string_single(self):
option = value_factory({
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red", ## optional??
VALUES_KEY_NAME: u"red"
})
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(d[VALUES_KEY_NAME], u"red")
def test_create_from_dict(self):
v = {u"type": u"string", u"value": u"red"}
option = value_factory(v)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, {u'type': u'string', u'value': u'red'})
#
values = option.values
self.assertTrue(isinstance(values, dict))
self.assertTrue(isinstance(values["value"], unicode))
self.assertEqual(values["value"], u"red")
def test_create_proper_string_list(self):
option = value_factory({
u"type": VALUE_TYPE_SET_STRING,
u"uri": u"colour/red", ## optional
u"name": u"red",
u"description": u"the colour red", ## optional??
u"image_uri": u"http://something.com/khgfdkyg.png",
VALUES_KEY_NAME: [u"red", u"blue"]
})
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(d[VALUES_KEY_NAME], [u"blue", u"red"])
def test_create_proper_string_list(self):
option = value_factory({
u"type": VALUE_TYPE_SET_STRING,
u"uri": u"colour/red",## optional
u"name": u"red",
u"description": u"the colour red", ## optional??
u"image_uri": u"http://something.com/khgfdkyg.png",
VALUES_KEY_NAME: [u"red", u"blue"]
})
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(option.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertEqual(d[VALUES_KEY_NAME], [u"blue", u"red"])
def test_create_from_dict(self):
v = {
u"type": u"string",
u"value": u"red"
}
option = value_factory(v)
d = option.as_json()
self.assertTrue(isinstance(option, OptionStringWinnowValue))
self.assertEqual(d, {u'type': u'string', u'value': u'red'})
#
values = option.values
self.assertTrue(isinstance(values, dict))
self.assertTrue(isinstance(values["value"], unicode))
self.assertEqual(values["value"], u"red")
def test_is_subset(self):
option1 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
option2 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
self.assertTrue(option1.issubset(option2))
option3 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}]
})
self.assertTrue(option3.issubset(option1))
self.assertFalse(option1.issubset(option3))
option4 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"pink",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}]
})
self.assertTrue(option4.issubset(option1))
option5 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"pink",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"pink",
}]
})
self.assertFalse(option5.issubset(option1))
def test_is_subset(self):
"""
should just work the same
but needs to check is subset of matching child options
"""
NESTED_OPTIONS_STRING_2 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
u"options":{
u"paint_coats":{
u"type": VALUE_TYPE_NUMERIC_STEP,
u"max": 6,
u"min": 1,
u"start": 1,
u"step": 1,
}
}
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
option1 = value_factory(NESTED_OPTIONS_STRING)
option2 = value_factory(NESTED_OPTIONS_STRING_2)
# same is subset
self.assertTrue(option1.issubset(option2))
NESTED_OPTIONS_STRING_3 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
u"options":{
u"paint_coats":{
u"type": VALUE_TYPE_NUMERIC_STEP,
u"max": 4,
u"min": 2,
u"start": 1,
u"step": 1,
}
}
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
NESTED_OPTIONS_STRING_4 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
u"options":{
u"paint_coats":{
u"type": VALUE_TYPE_NUMERIC_STEP,
u"max": 12,
u"min": 2,
u"start": 1,
u"step": 1,
}
}
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
option3 = value_factory(NESTED_OPTIONS_STRING_3)
option4 = value_factory(NESTED_OPTIONS_STRING_4)
# less is subset
self.assertTrue(option3.issubset(option1))
# more is not subset
self.assertFalse(option4.issubset(option1))
def test_intersection(self):
option1 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
u"image_url":
u"http://something.com/kurtjyrd.png",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
option2 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
u"scopes": [u"client"],
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"green",
u"description": u"the colour green",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"green",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue 2",
u"description": u"the colour blue again",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
option3 = option1.intersection(option2)
d = option3.as_json()
self.assertTrue(isinstance(option3, OptionStringWinnowValue))
self.assertEqual(option3.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], dict))
self.assertEqual(d[VALUES_KEY_NAME]["value"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["name"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["description"], u"the colour blue")
self.assertEqual(d[u"scopes"], [u"client"])
self.assertEqual(d[u"image_url"], u"http://something.com/kurtjyrd.png")
option8 = value_factory([u"green", u"blue"])
option9 = option1.intersection(option8)
d = option9.as_json()
self.assertTrue(isinstance(option3, OptionStringWinnowValue))
self.assertEqual(option3.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], dict))
self.assertEqual(d[VALUES_KEY_NAME]["value"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["name"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["description"], u"the colour blue")
self.assertEqual(d[u"image_url"], u"http://something.com/kurtjyrd.png")
option10 = option8.intersection(option1)
d = option10.as_json()
self.assertTrue(isinstance(option3, OptionStringWinnowValue))
self.assertEqual(option3.type, VALUE_TYPE_SET_STRING)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], dict))
self.assertEqual(d[VALUES_KEY_NAME]["value"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["name"], u"blue")
self.assertEqual(d[VALUES_KEY_NAME]["description"], u"the colour blue")
self.assertEqual(d[u"image_url"], u"http://something.com/kurtjyrd.png")
option4 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"green",
u"description": u"the colour green",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"green",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}]
})
option5 = option1.intersection(option4)
d = option5.as_json()
self.assertTrue(isinstance(option5, OptionStringWinnowValue))
self.assertEqual(option5.type, VALUE_TYPE_SET_STRING)
self.assertEqual(len(option5), 2)
self.assertTrue(isinstance(d, dict))
self.assertTrue(isinstance(d[VALUES_KEY_NAME], list))
self.assertTrue(isinstance(d[VALUES_KEY_NAME][0], dict))
self.assertTrue(d[VALUES_KEY_NAME][0]["value"] in [u"red", u"blue"])
self.assertTrue(d[VALUES_KEY_NAME][1]["value"] in [u"red", u"blue"])
self.assertTrue(
d[VALUES_KEY_NAME][0]["value"] != d[VALUES_KEY_NAME][1]["value"])
option6 = value_factory({
u"type":
VALUE_TYPE_SET_STRING,
u"name":
u"colour",
u"description":
u"please choose one of the colours",
VALUES_KEY_NAME: [{
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"green",
u"description": u"the colour green",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"green",
}, {
u"type": VALUE_TYPE_VALUE_STRING,
u"name": u"orange",
u"description": u"the colour orange",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"orange"
}]
})
option7 = option1.intersection(option6)
self.assertTrue(option7 is None)
def test_intersection(self):
"""
if there are matching values both with options then their options are merged
"""
NESTED_OPTIONS_STRING_2 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
u"options":{
u"paint_coats":{
u"type": VALUE_TYPE_NUMERIC_STEP,
u"max": Decimal(8),
u"min": Decimal(4),
u"start": Decimal(1),
u"step": Decimal(1),
}
}
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
option1 = value_factory(NESTED_OPTIONS_STRING)
option2 = value_factory(NESTED_OPTIONS_STRING_2)
intersection = option1.intersection(option2)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(set(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"][u"value"]) == {Decimal(4), Decimal(5), Decimal(6)})
## if they have different keys check merge ok
NESTED_OPTIONS_STRING_3 = {
u"type": VALUE_TYPE_SET_STRING,
u"name": u"colour",
u"description": u"please choose one of the colours",
VALUES_KEY_NAME: [
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"red",
u"description": u"the colour red",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"red",
u"options":{
u"apples":{
u"type": VALUE_TYPE_SET_STRING,
u"values": [u"cox", u"jazz", u"bramley"]
}
}
},
{
u"type": VALUE_TYPE_SET_STRING,
u"name": u"blue",
u"description": u"the colour blue",
u"image_uri": u"http://something.com/khgfdkyg.png",
u"value": u"blue"
}
]
}
option3 = value_factory(NESTED_OPTIONS_STRING_3)
intersection = option1.intersection(option3)
d = intersection.as_json()
self.assertTrue(isinstance(intersection, OptionStringWinnowValue))
self.assertTrue(isinstance(d, dict))
self.assertTrue(d[VALUES_KEY_NAME][1][u"value"] == u"red")
self.assertTrue(d[VALUES_KEY_NAME][1][u"options"][u"paint_coats"][u"max"] == Decimal(6))
options = d[VALUES_KEY_NAME][1][u"options"]
self.assertTrue(options[u"apples"] == [u"bramley", u"cox", u"jazz"])
