def test_bad_inputs(self):
"""convert should fail with bad inputs"""
for a, b, c in (('meter', 'yard', True), ('meter', 'yard', 'A'),
('meter', 'yard', '$')):
with self.assertRaises(
conversions_refactored.ConversionNotPossible):
conversions_refactored.convert(a, b, c)
def test_wrong_inputs(self):
"""convert should fail with wrong inputs"""
inputs = (
('meter', 'meter', 1),
('yard', 'yard', 1),
('mile', 'mile', 1),
('celsius', 'celsius', 1),
('kelvin', 'kelvin', 1),
('fahrenheit', 'fahrenheit', 1),
('meter', 'celsius', 1),
('meter', 'kelvin', 1),
('meter', 'fahrenheit', 1),
('yard', 'celsius', 1),
('yard', 'kelvin', 1),
('yard', 'fahrenheit', 1),
('mile', 'celsius', 1),
('mile', 'kelvin', 1),
('mile', 'fahrenheit', 1),
('celsius', 'meter', 1),
('celsius', 'yard', 1),
('celsius', 'mile', 1),
('kelvin', 'meter', 1),
('kelvin', 'yard', 1),
('kelvin', 'mile', 1),
('fahrenheit', 'meter', 1),
('fahrenheit', 'yard', 1),
('fahrenheit', 'mile', 1),
)
for a, b, c in inputs:
#print inputs
with self.assertRaises(
conversions_refactored.ConversionNotPossible):
conversions_refactored.convert(a, b, c)
def tests_convert(self):
expected = 623.15
returned = conversions_refactored.convert('celsius', 'kelvin', 350)
self.assertEqual(returned, expected)
expected = 662
returned = conversions_refactored.convert('celsius', 'fahrenheit', 350)
self.assertEqual(returned, expected)
expected = 160
returned = conversions_refactored.convert('fahrenheit', 'celsius', 320)
self.assertEqual(returned, expected)
expected = 433.15
returned = conversions_refactored.convert('fahrenheit', 'kelvin', 320)
self.assertEqual(returned, expected)
expected = 330
returned = conversions_refactored.convert('kelvin', 'celsius', 603.15)
self.assertEqual(returned, expected)
expected = 626
returned = conversions_refactored.convert('kelvin', 'fahrenheit',
603.15)
self.assertEqual(returned, expected)
expected = None
returned = conversions_refactored.convert('kelvin', 'miles', 100)
self.assertEqual(returned, expected)
expected = "Please enter valid conversion units."
returned = conversions_refactored.convert('meters', 'fahrenheit', 100)
self.assertEqual(returned, expected)
expected = None
returned = conversions_refactored.convert('celsius', 'yards', 100)
self.assertEqual(returned, expected)
def testSanity(self):
"""converting from one unit to itself"""
for from_to in known_values:
#print from_to
(a, b) = from_to.split('-')
for value in range(int(min(known_values[from_to])),
int(max(known_values[from_to]))):
#print "testing value:",value
compare1 = conversions_refactored.convert(a, b, value)
compare2 = conversions_refactored.convert(b, a, compare1)
self.assertEqual(value, round(compare2))
def test_convertMetersToYards(self):
fromUnit = 'm'
toUnit = 'ft'
value = 2
expected = "Incompatible units entered"
actual = ""
try:
conversions_refactored.convert(fromUnit, toUnit, value)
except Exception:
actual = "Incompatible units entered"
self.assertEqual(expected, actual, msg="Exception has thrown"
) # **not a practical test to demonstrate
def testMitoY(self):
"""docstring"""
for integer, numeral in self.mitoyvalues:
result = conversions_refactored.convert('miles', 'yards', integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def testYtoMet(self):
"""docstring"""
for integer, numeral in self.ytometvalues:
result = conversions_refactored.convert('yards', 'meters', integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def test_convert(self):
"""
conversions_refactored.convert(): Test unit conversion
:return:
"""
tmp_keys = self.temp_values[0].keys()
dst_keys = self.dist_values[0].keys()
print 'conversions_refactored.convert() - Legal conversions test:'
for x in xrange(100):
if x % 2:
from_unit = random.choice(tmp_keys)
to_unit = random.choice(tmp_keys)
testme = self.temp_values
print 'Testing temp conversion:'
else:
from_unit = random.choice(dst_keys)
to_unit = random.choice(dst_keys)
testme = self.dist_values
print 'Testing length conversion'
for row in testme:
result = ref.convert(from_unit, to_unit, row[from_unit])
print self.sep
print 'Input Unit: ', from_unit.title()
print 'Output Unit: ', to_unit.title()
print 'Input Value: ', row[from_unit]
print 'Output value: ', result
print 'Expected Value: ', row[to_unit]
self.assertAlmostEqual(row[to_unit], result, 1)
def test_convert(self):
fromUnit = 'K'
toUnit = 'K'
value = 300
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertTrue(actual is value,
msg="Conversion of unit to itself failed")
def test_am_i_me(self):
print(TestConversionsRefactored.test_am_i_me.__name__)
for i in [
'yards', 'meters', 'miles', 'fahrenheit', 'kelvin', 'celsius'
]:
print(f"Testing is {i} converted to itself is the same value")
result = conversions_refactored.convert(i, i, 1.0)
self.assertEqual(result, 1)
def testCtoF(self):
"""tests that convertCelsiusToFahrenheit returns the correct values"""
for integer, numeral in self.ctofvalues:
result = conversions_refactored.convert('Celsius', 'Fahrenheit',
integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def testKtoC(self):
"""tests that convert returns the correct Kelvin To Celsius values"""
for integer, numeral in self.ktocvalues:
result = conversions_refactored.convert('Kelvin', 'Celsius',
integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def testFtoK(self):
"""tests that convert returns the correct Fahrenheit To Kelvin values"""
for integer, numeral in self.ftokvalues:
result = conversions_refactored.convert('Fahrenheit', 'Kelvin',
integer)
self.assertEqual(numeral,
result,
msg='Incorrect result, calculation error')
def testConversionNotPossible(self):
""" Tests to see if ConversionNotPossible is raised.
Args:
None
Returns:
Assertion
"""
self.assertRaises(conversions_refactored.ConversionNotPossible,
conversions_refactored.convert('k', 'mi', 1))
def testBadConversions(self):
badConversions = (("Fahrenheit", "Meter", 123,
123), ("Celsius", "Mile", 123, 123),
("Mile", "Kelvin", 123, 123), ("Yard", "Fahrenheit",
123, 123))
for (fromUnit, toUnit, fromVal, toVal) in badConversions:
self.assertRaises(
conversions_refactored.ConversionNotPossible,
conversions_refactored.convert(fromUnit, toUnit, fromVal))
def testConvert(self):
""" test conversion between compatible units, including a unit to itself """
for inst in self.knownValues:
for unitFrom, v1 in inst.iteritems():
for unitTo, v2 in inst.iteritems():
print 'checking convert(%s, %s, %f) = %f' % (
unitFrom, unitTo, v1, v2)
result = convref.convert(unitFrom, unitTo, v1)
self.assertEqual(v2, result)
def test_refactored_conversions_function(self):
for units, values in self.cases.items():
for n, expected in values:
from_unit, to_unit = units
actual = convert(from_unit, to_unit, n)
self.assertAlmostEqual(expected, actual, places=1,
msg=f'{from_unit} to {to_unit}')
self.assertEqual(123, convert('Meter', 'Meter', 123),
msg='Converting from one unit to itself '
'should return the same value')
with self.assertRaises(ConversionNotPossible,
msg='Converting from incompatible units '
'should raise a '
'ConversionNotPossible exception'):
convert('Fahrenheit', 'Yard', 123)
def testIdentityCase(self):
""" Tests to see if the conversions_refactored module returns the same result if the
source and destination units are the same"""
testSet = ['fahrenheit', 'celsius', 'kelvin', 'miles', 'meters', 'yards']
for item in testSet:
unit1 = unit2 = item
for value in self.randomSet:
self.assertEqual(conversions_refactored.convert(unit1, unit2, value), int(value))
def test_convertCtoF(self):
fromUnit = 'C'
toUnit = 'F'
value = 350
expected = 662
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Celsius", "Fahrenheit"))
def test_convertCtoF(self):
fromUnit = 'C'
toUnit = 'F'
value = 300
expected = 572.00
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg="Celsius to Fahrenheit conversion failed")
def test_convertMetersToMiles(self):
fromUnit = 'M'
toUnit = 'mi'
value = 2000
expected = 1.24
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Meters", "Miles"))
def test_convertYardsToMiles(self):
fromUnit = 'yd'
toUnit = 'mi'
value = 150
expected = 0.085
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=3,
msg=msg.format("Yards", "Miles"))
def test_convertMilesToYards(self):
fromUnit = 'mi'
toUnit = 'yd'
value = 5
expected = 8800
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Miles", "Yards"))
def test_convertFtoK(self):
fromUnit = 'F'
toUnit = 'K'
value = 350
expected = 449.82
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Fahrenheit", "Kelvin"))
def test_convertKtoC(self):
fromUnit = 'K'
toUnit = 'C'
value = 350
expected = 76.85
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Kelvin", "Celsius"))
def test_convertKtoF(self):
fromUnit = 'K'
toUnit = 'F'
value = 350
expected = 170.33
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Kelvin", "Fahrenheit"))
def test_convertMilesToMeters(self):
fromUnit = 'Mi'
toUnit = 'm'
value = 5
expected = 8046.72
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Miles", "Meters"))
def test_convertMetersToYards(self):
fromUnit = 'm'
toUnit = 'm'
value = 15
expected = value
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg=msg.format("Meters", "Meters"))
def testConvert_SameValue(self):
"""convert() should return same value if converting from one unit to itself"""
testdata = (('kelvin', 'kelvin', 0, 0), ('celsius', 'celsius', -1, -1),
('fahrenheit', 'fahrenheit', 32.05,
32.05), ('miles', 'miles', 22, 22),
('meters', 'meters', 3, 3), ('yards', 'yards', 14, 14))
for a, b, val, output in testdata:
self.assertEqual((conversions_refactored.convert(a, b, val)),
output)
def test_convertYardstoMeters(self):
fromUnit = 'Yards'
toUnit = 'Meters'
value = 20
expected = 18.288
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=3,
msg="Yards to Meters conversion failed")
def test_convertMilestoYards(self):
fromUnit = 'Miles'
toUnit = 'Yards'
value = 5
expected = 8800
actual = conversions_refactored.convert(fromUnit, toUnit, value)
self.assertAlmostEqual(expected,
actual,
places=2,
msg="Miles to Yards conversion failed")
def testConvertMetersToYards(self):
result = conversions_refactored.convert('Meter', 'Yard', 1.00)
self.assertEqual(1.0936, result)
def testConvertYardsToMiles(self):
result = conversions_refactored.convert('Yard', 'Mile', 10000.0416)
self.assertEqual(5.6819, result)
def testConvertMilesToYards(self):
result = conversions_refactored.convert('Mile', 'Yard', 5.6819)
self.assertEqual(10000.0415855, result)
def testConvertCelsiusToKelvin(self):
result = conversions_refactored.convert('Celsius', 'Kelvin', 300.00)
self.assertEqual(573.15, result)
def testConvertKelvinToCelsius(self):
result = conversions_refactored.convert('Kelvin', 'Celsius', 573.15)
self.assertEqual(300.00, result)
def testCelsiusToFahrenheit(self):
result = conversions_refactored.convert('Celsius', 'Fahrenheit', 300.00)
self.assertEqual(572.00, result)
def testConvertMetersToMiles(self):
result = conversions_refactored.convert('Meter', 'Mile', 1.00)
self.assertEqual(0.0006214, result)
def testFahrenheitToCelsius(self):
result = conversions_refactored.convert('Fahrenheit', 'Celsius', 572.00)
self.assertEqual(300.00, result)
def testConvertMilesToMeters(self):
result = conversions_refactored.convert('Mile', 'Meter', 1.00)
self.assertEqual(1609.3470879, result)
def testConvertSelf(self): for measure in self.measures: result = conversions_refactored.convert(measure, measure, 10.00) self.assertEqual(10.00, result)
def testFahrenheitToKelvin(self):
result = conversions_refactored.convert('Fahrenheit', 'Kelvin', 80.33)
self.assertEqual(300.00, result)
def testKelvinToFahrenheit(self):
result = conversions_refactored.convert('Kelvin', 'Fahrenheit', 300.00)
self.assertEqual(80.33, result)
def testConvertYardsToMeters(self):
result = conversions_refactored.convert('Yard', 'Meter', 1.00)
self.assertEqual(0.9144111, result)
