senaduka/old-krovovi-kalkulator
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Senad Uka
2017-11-07 09:23:57 +01:00
commit 0eee92660a
356 changed files with 747259 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
test/services/__init__.py Normal file
View File

49
test/services/doc_gen_service_test.py Normal file
View File

@@ -0,0 +1,49 @@
import unittest
from unittest.mock import MagicMock
from nose.tools import eq_, assert_raises
from helix.Services.doc_gen_service import DocGenService, DocGenServiceError
class DocGenServiceTest(unittest.TestCase):
def setUp(self):
self.request_maker = MagicMock()
self.request_builder = MagicMock()
self.request_builder.build.return_value = {"key": "value"}
self.user_values = MagicMock()
self.user_values.system_type.return_value = "MySystemType"
self.subject = DocGenService(self.request_maker, self.request_builder)
def test_generate_everything_valid(self):
expected = "expected value"
post_return = MagicMock()
post_return.content = expected
post_return.status_code = 200
self.request_maker.post.return_value = post_return
eq_(self.subject.generate(), expected)
self.request_builder.build.assert_called_once_with()
self.request_maker.post.assert_called_once_with('https://dcs.us.sunpower.com/ws/docgen/docx/generatePdf', "{\"key\": \"value\"}", headers={'content-type': 'application/json'})
def test_generate_returns_400(self):
expected = "some error"
post_return = MagicMock()
post_return.content = expected
post_return.status_code = 400
self.request_maker.post.return_value = post_return
assert_raises(DocGenServiceError, self.subject.generate)
self.request_builder.build.assert_called_once_with()
self.request_maker.post.assert_called_once_with('https://dcs.us.sunpower.com/ws/docgen/docx/generatePdf', "{\"key\": \"value\"}", headers={'content-type': 'application/json'})
def test_generate_returns_500(self):
expected = "some error"
post_return = MagicMock()
post_return.content = expected
post_return.status_code = 500
self.request_maker.post.return_value = post_return
assert_raises(DocGenServiceError, self.subject.generate)
self.request_builder.build.assert_called_once_with()
self.request_maker.post.assert_called_once_with('https://dcs.us.sunpower.com/ws/docgen/docx/generatePdf', "{\"key\": \"value\"}", headers={'content-type': 'application/json'})

415
test/services/dxf_service_test.py Normal file
View File

@@ -0,0 +1,415 @@
import time
import unittest
from nose.tools import eq_
from helix.Services.dxf_helper import DXFHelper
from helix.Services.dxf_service import DXFService
from helix.constants.module_type_constants.dual_tilt_128_cell_constants import DualTilt128CellConstants
from helix.constants.module_type_constants.dual_tilt_96_cell_constants import DualTilt96CellConstants
from helix.constants.module_type_constants.dual_tilt_pseries_constants import DualTiltPSeriesConstants
from helix.constants.module_type_constants.single_tilt_128_cell_constants import SingleTilt128CellConstants
from helix.constants.module_type_constants.single_tilt_96_cell_constants import SingleTilt96CellConstants
from helix.constants.module_type_constants.single_tilt_pseries_constants import SingleTiltPSeriesConstants
from helix.constants.system_type import SystemType
from helix.models.dxf.polygon import Polygon
from helix.models.subarray import Subarray
from helix.validators.subarray_validator import SubarrayValidator
from test.fixtures.dxf.expected_dual_tilt_128_cell import expected_dual_tilt_128_cell_panels
from test.fixtures.dxf.expected_dual_tilt_96_cell import expected_dual_tilt_96_cell_panels
from test.fixtures.dxf.expected_dual_tilt_96_cell_fuzzy import expected_dual_tilt_96_cell_panels_fuzzy
from test.fixtures.dxf.expected_dual_tilt_pseries import expected_dual_tilt_pseries_panels
from test.fixtures.dxf.expected_single_tilt_128_cell import expected_single_tilt_128_cell_panels
from test.fixtures.dxf.expected_single_tilt_96_cell import expected_single_tilt_96_cell_panels
from test.fixtures.dxf.expected_single_tilt_96_cell import expected_single_tilt_96_cell_panels
from test.fixtures.dxf.expected_single_tilt_pseries import expected_single_tilt_pseries_panels
class DXFServiceTest(unittest.TestCase):
def setUp(self):
self.subject = DXFService()
# def test_integration_parse_single_tilt_96_cell(self):
# with open('test/fixtures/dxf/input_single_tilt_96_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content,
# SingleTilt96CellConstants(), SystemType.singleTilt,
# 58.7878, DXFHelper(),
# SubarrayValidator())
#
# del result['buildings']
# del result['modules']
# del result['size']
# del result['lb_polygons']
#
# expected = {
# 'panels': expected_single_tilt_96_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=550, start_row=0),
# Subarray(subarray_number=2, size=575, start_row=550),
# Subarray(subarray_number=3, size=638, start_row=1125),
# Subarray(subarray_number=4, size=667, start_row=1763),
# ]
# }
# for i in range(len(expected["panels"]) - 1):
# eq_(result["panels"][i], expected["panels"][i])
#
# for i in range(len(expected["subarrays"]) - 1):
# eq_(result["subarrays"][i], expected["subarrays"][i])
#
# def test_integration_parse_dual_tilt_96_cell(self):
# with open('test/fixtures/dxf/input_dual_tilt_96_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTilt96CellConstants(), SystemType.dualTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_dual_tilt_96_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=87, start_row=0),
# Subarray(subarray_number=2, size=32, start_row=87),
# Subarray(subarray_number=3, size=40, start_row=119),
# Subarray(subarray_number=4, size=85, start_row=159),
# Subarray(subarray_number=5, size=28, start_row=244),
# Subarray(subarray_number=6, size=77, start_row=272),
# Subarray(subarray_number=7, size=95, start_row=349),
# Subarray(subarray_number=8, size=93, start_row=444),
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 8)
# eq_(len(result['panels']), 537)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_integration_parse_new_single_tilt_96_cell(self):
# with open('test/fixtures/dxf/input_new_single_tilt_96_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, SingleTilt96CellConstants(), SystemType.singleTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_new_single_tilt_96_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=216, start_row=0)
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 1)
# eq_(len(result['panels']), 216)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_integration_parse_new_dual_tilt_96_cell(self):
# with open('test/fixtures/dxf/input_new_dual_tilt_96_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTilt96CellConstants(), SystemType.dualTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_new_dual_tilt_96_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=135, start_row=0)
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 1)
# eq_(len(result['panels']), 135)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_integration_parse_dual_tilt_96_cell_fuzzy_wind_zone(self):
# with open('test/fixtures/dxf/input_dual_tilt_96_cell_angles_less_than_80.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTilt96CellConstants(),
# SystemType.dualTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_dual_tilt_96_cell_panels_fuzzy,
# 'subarrays': [
# Subarray(subarray_number=1, size=115, start_row=0),
# Subarray(subarray_number=2, size=327, start_row=115),
# Subarray(subarray_number=3, size=342, start_row=442),
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), len(expected['subarrays']))
# eq_(len(result['panels']), len(expected['panels']))
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_integration_parse_dual_tilt_128_pre_consolidated(self):
# with open('test/fixtures/dxf/input_dual_tilt_96_cell_preconsolidated.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTilt96CellConstants(),
# SystemType.dualTilt,
# 58.7878,
# DXFHelper(),
# SubarrayValidator())
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['modules']), 1550)
#
# def test_integration_parse_new_single_tilt_128_cell(self):
# with open('test/fixtures/dxf/input_new_single_tilt_128_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, SingleTilt128CellConstants(), SystemType.singleTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_new_single_tilt_128_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=162, start_row=0)
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 1)
# eq_(len(result['panels']), 162)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_integration_parse_new_dual_tilt_128_cell(self):
# with open('test/fixtures/dxf/input_new_dual_tilt_128_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTilt128CellConstants(), SystemType.dualTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_new_dual_tilt_128_cell_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=100, start_row=0)
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 1)
# eq_(len(result['panels']), 100)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
def test_integration_parse_new_single_tilt_pseries(self):
with open('test/fixtures/dxf/input_single_tilt_pseries.dxf', 'r',
newline='') as dxf_file:
dxf_content = dxf_file.read()
subject = DXFService()
result = subject.parse(dxf_content, SingleTiltPSeriesConstants(), SystemType.singleTilt, 58.7878, DXFHelper(),
SubarrayValidator())
expected = {
'is_panel_drawing_inaccurate': False,
'panels': expected_single_tilt_pseries_panels,
'subarrays': [
Subarray(subarray_number=1, size=63, start_row=0)
]
}
eq_(len(result['panels']), len(result['modules']))
eq_(len(result['subarrays']), 1)
eq_(len(result['panels']), 63)
del result['modules']
del result['size']
del result['lb_polygons']
del result['buildings']
eq_(result, expected)
# def test_integration_parse_new_dual_tilt_pseries(self):
# with open('test/fixtures/dxf/input_new_dual_tilt_pseries.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
#
# subject = DXFService()
#
# result = subject.parse(dxf_content, DualTiltPSeriesConstants(), SystemType.dualTilt, 58.7878, DXFHelper(),
# SubarrayValidator())
#
# expected = {
# 'panels': expected_new_dual_tilt_pseries_panels,
# 'subarrays': [
# Subarray(subarray_number=1, size=100, start_row=0)
# ]
# }
#
# eq_(len(result['panels']), len(result['modules']))
# eq_(len(result['subarrays']), 1)
# eq_(len(result['panels']), 100)
#
# del result['modules']
# del result['size']
# del result['lb_polygons']
# del result['buildings']
#
# eq_(result, expected)
#
# def test_parse(self):
# mock_dxf_grabber = MagicMock()
#
# dxf_return_values = [
# MagicMock(),
# MagicMock()
# ]
#
# mock_dxf_grabber.return_value = MagicMock(entities=dxf_return_values)
# dxf_helper = MagicMock()
#
# subarray_validator = MagicMock()
#
# buildings = [Polygon(points=[(0, 0), (0, 10), (10, 10), (10, 0)])]
# modules = [Polygon(points=[(0, 0), (0, 5), (5, 5), (5, 0)])]
# dxf_helper.build_polygons.return_value = (buildings, modules)
# dxf_helper.consolidate_dual_tilt_modules.return_value = modules
#
# translated_buildings = [Polygon(points=[(0, 0), (0, 4), (4, 4), (4, 0)])]
# translated_modules = [Polygon(points=[(0, 0), (0, 1), (1, 1), (1, 0)])]
# dxf_helper.translate_towards_origin.return_value = (translated_buildings, translated_modules)
#
# panels = [MagicMock(), MagicMock()]
# panel_graph = [MagicMock()]
# subarrays = [Subarray(subarray_number=0)]
#
# dxf_helper.generate_panels.return_value = panels
# dxf_helper.build_node_graph.return_value = panel_graph
# dxf_helper.detect_subarrays.return_value = subarrays
# dxf_helper.should_consolidate_modules.return_value = True
# dxf_helper.is_new_aurora_format.return_value = False
#
# module_constants = MagicMock(panel_spacing=(2, 2))
# system_type = MagicMock()
# l_b = MagicMock()
# module_format = None
# subject = DXFService()
#
# with patch('dxfgrabber.read', mock_dxf_grabber):
# result = subject.parse("doesn't matter",
# module_constants,
# system_type,
# l_b, dxf_helper,
# subarray_validator)
#
# assert mock_dxf_grabber.called
# dxf_helper.build_polygons.assert_called_once_with(dxf_return_values)
# dxf_helper.consolidate_dual_tilt_modules.assert_called_once_with(modules, system_type, module_format)
#
# dxf_helper.translate_towards_origin.assert_called_once_with(buildings, modules)
#
# dxf_helper.generate_panels.assert_called_once_with(modules, translated_modules)
#
# dxf_helper.build_node_graph.assert_called_once_with(panels, module_constants.panel_spacing)
#
# dxf_helper.detect_subarrays.assert_called_once_with(panel_graph, panels)
# dxf_helper.detect_panel_types.assert_called_once_with(panel_graph)
# dxf_helper.detect_wind_zones.assert_called_once_with(panels,
# translated_buildings,
# translated_modules,
# l_b, system_type)
# subarray_validator.validate_subarray.assert_called_once_with(panel_graph,
# 0,
# system_type)
#
# eq_(result, {
# 'size': (4, 4),
# 'buildings': translated_buildings,
# 'modules': translated_modules,
# 'panels': panels,
# 'subarrays': subarrays,
# 'lb_polygons': dxf_helper.l_b_polygons()
# })
#
# # Performance tests.
#
# def test_dxf_service_performance_dual_tilt_96_cell(self):
# with open('test/fixtures/dxf/input_dual_tilt_96_cell.dxf', 'r',
# newline='') as dxf_file:
# dxf_content = dxf_file.read()
# subject = DXFService()
#
# results = []
#
# run_count = 1
#
# last_result = None
#
# for _ in range(run_count):
# start = time.clock()
# last_result = subject.parse(dxf_content, DualTilt96CellConstants(), SystemType.dualTilt, 40, DXFHelper(),
# SubarrayValidator())
# end = time.clock()
# results.append(end - start)
#
# average_run_time = sum(results) / run_count
#
# eq_(len(last_result['subarrays']), 8)
# assert average_run_time < 10, "Expected to take less than 10 seconds on average to parse even large dxfs"
#
# print("%d runs took on average %f seconds" % (run_count, sum(results) / run_count))