def test_invalid_coffeemaker_id():
with pytest.raises(Exception):
handler.handler(
{
'coffeemakerId': 'Moskova',
'eventType': 'out-of-coffee'
}, {})
def test_invalid_event_type():
with pytest.raises(Exception):
handler.handler(
{
'serialNumber': 'G030PT025262W2X0',
'clickType': 'TRIPLE'
}, {})
def test_end_brew():
table = createTable()
slackEventConsumer = SlackEventConsumer()
startTime = handler.format_timestamp(datetime.now())
endTime = handler.format_timestamp(datetime.now())
table.put_item(Item={
'coffeemakerId': 'Hki1',
'startTime': startTime,
'endTime': endTime
})
handler.handler(
{
'coffeemakerId': 'Hki1',
'eventType': 'end',
'startTime': startTime,
'endTime': endTime
}, {}, slackEventConsumer.consume)
items = getItems(table, 'Hki1')
assert len(items) == 1
assert items[0]['startTime'] == startTime
assert items[0]['endTime'] == endTime
assert len(slackEventConsumer.events) == 1
assert slackEventConsumer.events[0]['coffeemaker_id'] == 'Hki1'
assert slackEventConsumer.events[0]['msg'] == slack_messages['brew_ended']
def test_missing_latestexection_key(self, mocked_client):
handler.MAX_WAIT_FOR_RESPONSE = 0
handler.WAIT_INCREMENT = 1
response = _get_mocked_response('missing-latestexecution-key')
mocked_client.get_pipeline_state.return_value = response
handler.handler(_mocked_event(), {})
mocked_client.put_approval_result.assert_not_called()
def main():
print(request)
data = request.get_data()
f = io.StringIO()
with redirect_stdout(f):
handler(request.get_data())
return f.getvalue()
def test_out_of_coffee():
event_consumer = EventConsumer()
handler.handler({
'serialNumber': 'G030PT025262W2X0',
'clickType': 'LONG'
}, {}, event_consumer.consume)
assert event_consumer.coffee_event['eventType'] == 'out-of-coffee'
assert event_consumer.coffee_event['coffeemakerId'] == 'Hki1'
def test_end_without_started_brew():
create_table()
event_consumer = EventConsumer()
handler.handler({
'serialNumber': 'G030PT025262W2X0',
'clickType': 'SINGLE'
}, {}, event_consumer.consume)
assert event_consumer.coffee_event == None
def test_start():
event_consumer = EventConsumer()
handler.handler({
'serialNumber': 'G030PT025262W2X0',
'clickType': 'DOUBLE'
}, {}, event_consumer.consume)
assert event_consumer.coffee_event['eventType'] == 'start'
assert event_consumer.coffee_event['coffeemakerId'] == 'Hki1'
assert len(event_consumer.coffee_event['startTime']) == 23
def test_out_of_coffee():
slackEventConsumer = SlackEventConsumer()
handler.handler({
'coffeemakerId': 'Hki1',
'eventType': 'out-of-coffee'
}, {}, slackEventConsumer.consume)
assert len(slackEventConsumer.events) == 1
assert slackEventConsumer.events[0]['coffeemaker_id'] == 'Hki1'
assert slackEventConsumer.events[0]['msg'] == slack_messages[
'out_of_coffee']
def test_ows_db_update(self, mock_client, mock_update_cubedash_call):
event = {
"Records": [
{
"Sns": {
"Message": "eks:ows_20190101\n",
"Timestamp": "Timestamp",
"MessageId": "Message_1234"
},
},
]
}
handler(event, None)
mock_update_cubedash_call.assert_called
def test_it_can_throw_a_value_error_when_request_type_is_not_recognised(
self):
file = {
'session': {
'application': {
'applicationId':
"amzn1.ask.skill.1001f962-280f-4cc9-a9f5-7888feba598c"
}
},
'request': {
'type': 'AnotherRequestTypeThat is invalid'
}
}
with self.assertRaises(ValueError):
handler(file, {})
def test_end():
table = create_table()
start = handler.format_timestamp(datetime.today() - timedelta(hours=3))
table.put_item(Item={'coffeemakerId': 'Hki1', 'startTime': start})
event_consumer = EventConsumer()
handler.handler({
'serialNumber': 'G030PT025262W2X0',
'clickType': 'SINGLE'
}, {}, event_consumer.consume)
assert event_consumer.coffee_event['eventType'] == 'end'
assert event_consumer.coffee_event['coffeemakerId'] == 'Hki1'
assert event_consumer.coffee_event['startTime'] == start
assert len(event_consumer.coffee_event['endTime']) == 23
def test_db_name_error(self, mock_client, mock_update_cubedash_call):
event = {
"Records": [
{
"Sns": {
"Message": "dev:20190101\n",
"Timestamp": "Timestamp",
"MessageId": "Message_1234"
},
},
]
}
try:
handler(event, None)
except SystemExit:
mock_update_cubedash_call.assert_called
def spider(urlList):
new_list = []
man = handler.handler()
man.patchIndex(URL_LIST)
for url in urlList:
new_list = getinfo(url)
man.handle(new_list)
class Server():
users = {}
hand = handler()
def __init__(self, host, port):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))
def ready(self):
self.sock.listen(5)
while True:
c, addr = self.sock.accept()
threading.Thread(target=self.listenToClient,
args=(c, addr)).start()
def listenToClient(self, client, address):
size = 1024
while True:
try:
data = client.recv(size)
if data:
# Set the response to echo back the recieved data
response = hand.handle()
client.send(response)
else:
raise error('Client disconnected')
except:
client.close()
return False
def test_handler(mock_s3_w_resource, mysql_test_connection, test_buckets,
mock_env_for_lambda_function, test_table, n):
import handler
# GIVEN a set of n test records written as a csv to s3
test_records = get_test_records(n)
test_key = 'some_file.csv'
test_bucket = test_buckets['test_bucket']
event = helpers.dict_to_s3_csv_return_event(test_records, test_bucket,
test_key, mock_s3_w_resource)
# WHEN we pass it to handler.handler
handler.handler(event)
# THEN we expect to see that content written into the test table
returned_records = helpers.table_contents(mysql_test_connection,
test_table)
assert returned_records == test_records
def test_it_can_send_launch_request_json_and_respond_with_correct_json(
self):
file = self._get_json_file('launch_request.json')
actual_response = handler(file, {})
self.assertIn('version', actual_response)
self.assertIn('sessionAttributes', actual_response)
self.assertIn('response', actual_response)
def index():
req = request.args.get('', None)
if req:
try:
data = ast.literal_eval(req)
except:
return "Incorrect data. Please enter data in the format: your_url/start/?={'data' : [1, 2, 3, 4, 5], 'rule' : ['a','b','c','d','e','f']}"
return handler(data)
return "No data. Please enter data in the format: your_url/start/?={'data' : [1, 2, 3, 4, 5], 'rule' : ['a','b','c','d','e','f']}"
def test_end_when_already_ended():
table = create_table()
start = handler.format_timestamp(datetime.today() - timedelta(hours=3))
end = handler.format_timestamp(datetime.today() - timedelta(hours=2))
table.put_item(Item={
'coffeemakerId': 'Hki1',
'startTime': start,
'endTime': end
})
event_consumer = EventConsumer()
handler.handler({
'serialNumber': 'G030PT025262W2X0',
'clickType': 'SINGLE'
}, {}, event_consumer.consume)
assert event_consumer.coffee_event == None
def test_status(self, actions_do_status):
event = {
"httpMethod": "GET",
"pathParameters": {
"action": "status",
},
}
resp = handler.handler(event, config={"some": "config"})
self.assertEqual(resp, attr.asdict(_EXAMPLE_STATUS))
actions_do_status.assert_called_once_with({"some": "config"})
def test_start_brew():
table = createTable()
slackEventConsumer = SlackEventConsumer()
startTime = handler.format_timestamp(datetime.now())
handler.handler(
{
'coffeemakerId': 'Hki1',
'eventType': 'start',
'startTime': startTime
}, {}, slackEventConsumer.consume)
items = getItems(table, 'Hki1')
assert len(items) == 1
assert items[0]['startTime'] == startTime
assert items[0].get('endTime', None) == None
assert len(slackEventConsumer.events) == 1
assert slackEventConsumer.events[0]['coffeemaker_id'] == 'Hki1'
assert slackEventConsumer.events[0]['msg'] == slack_messages[
'brew_started']
def test_handler():
test_event1 = {
"body":
'{"question": "' + question_one + '", "context": "' + context + '"}'
}
res = handler(test_event1, '')
# lambci test_event1
# docker run --rm -v "$PWD":/var/task:ro,delegated lambci/lambda:python3.8 handler.handler '{"question": "Who has the most covid-19 deaths?", "context":"The US has passed the peak on new coronavirus cases,President Donald Trump said and predicted that some states would reopen this month. The US has over 637,000 confirmed Covid-19 cases and over 30,826 deaths, the highest for any country in the world."}'
def test_brew_ready():
table = createTable()
slackEventConsumer = SlackEventConsumer()
startTime = handler.format_timestamp(datetime.now() -
timedelta(seconds=300))
table.put_item(Item={'coffeemakerId': 'Hki1', 'startTime': startTime})
handler.handler({'eventType': "check-status"}, {},
slackEventConsumer.consume)
items = getItems(table, 'Hki1')
assert len(items) == 1
assert items[0]['startTime'] == startTime
assert items[0].get('endTime', None) == None
assert len(slackEventConsumer.events) == 1
assert slackEventConsumer.events[0]['coffeemaker_id'] == 'Hki1'
assert slackEventConsumer.events[0]['msg'] == slack_messages[
'coffee_ready']
def test_brew_ready_and_timeout():
table = createTable()
slackEventConsumer = SlackEventConsumer()
brewedInOulu = handler.format_timestamp(datetime.now() -
timedelta(seconds=7800))
brewedInHki = handler.format_timestamp(datetime.now() -
timedelta(seconds=400))
table.put_item(Item={'coffeemakerId': 'Oulu1', 'startTime': brewedInOulu})
table.put_item(Item={'coffeemakerId': 'Hki1', 'startTime': brewedInHki})
handler.handler({'eventType': "check-status"}, {},
slackEventConsumer.consume)
assert len(slackEventConsumer.events) == 2
assert slackEventConsumer.events[0]['coffeemaker_id'] == 'Hki1'
assert slackEventConsumer.events[0]['msg'] == slack_messages[
'coffee_ready']
assert slackEventConsumer.events[1]['coffeemaker_id'] == 'Oulu1'
assert slackEventConsumer.events[1]['msg'] == slack_messages[
'brew_timeout']
def test_handler_success(mocker):
i = {
"queryStringParameters": {
"latitude": "37.421542",
"longitude": "-122.085589",
"date": "2005-05-26-10458.68"
}
}
coordinates = {"latitude": 37.857713, "longitude": -122.544543}
url = 'https://www.google.com/maps/place/37.857713,-122.544543'
body = {'coordinates': coordinates, 'url': url}
r = {'statusCode': 200, 'body': json.dumps(body)}
assert handler.handler(i, '') == r
def test_handler_invalid_url(mocker):
mocker.patch.object(handler, 'validate_url')
i = {
"queryStringParameters": {
"latitude": "37.421542",
"longitude": "-122.085589",
"date": "2005-05-26-10458.68"
}
}
body = {'errorMessage': "Error validating URL."}
r = {'statusCode': 500, 'body': json.dumps(body)}
handler.validate_url.return_value = False
assert handler.handler(i, '') == r
def test_down(self, _actions_do_status, actions_do_down):
event = {
"httpMethod": "GET",
"pathParameters": {
"action": "down",
},
"queryStringParameters": {
"to": "10",
},
}
resp = handler.handler(event, config={"some": "config"})
self.assertEqual(resp, {"foo": "bar"})
actions_do_down.assert_called_once_with({"some": "config"},
_EXAMPLE_STATUS,
worker_count=10)
def upload_file():
if request.method == 'POST':
# check if the post request has the file part
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
file = request.files['file']
# if user does not select file, browser also
# submit an empty part without filename
if file.filename == '':
flash('No selected file')
return redirect(request.url)
if file and allowed_file(file.filename):
return handler(file)
return '''
def main():
# start recording
r.record()
# request to MS STT
data = h.handler()
if 'DisplayText' in data.keys():
result = data['DisplayText']
print("You say:", result)
print("Wait for LUIS...")
command = l.get_command(result)
print("Command:", command)
else:
print("I don't understand you.")
print("Recived data: ", data)
def test_connect(self, _actions_do_status, actions_do_connect):
event = {
"httpMethod": "GET",
"pathParameters": {
"action": "connect",
},
"queryStringParameters": {
"up": "10",
"force_update": "true",
},
}
resp = handler.handler(event, config={"some": "config"})
self.assertEqual(resp, {"foo": "bar"})
actions_do_connect.assert_called_once_with({"some": "config"},
_EXAMPLE_STATUS,
worker_count=10,
force_update=True)
#!/usr/bin/python -i
if __name__ == '__main__':
from handler import handler
import ConfigParser, os, sys, serial
from struct import pack, unpack
config = ConfigParser.SafeConfigParser()
if not os.path.isfile('xbee.ini'):
config.add_section('modem')
config.set('modem', 'port', '/dev/whatever')
with open('xbee.ini', 'wb') as configfile:
config.write(configfile)
print "Edit xbee.ini for your modem port"
sys.exit(1)
config.read('xbee.ini')
ser = serial.Serial(config.get('modem', 'port'), 57600)
hd = handler(ser)
nodes = hd.nodes_by_identifier
infile = sys.stdin
#
# Prepare transformation-2: output
#
if "-" == outfile:
f = sys.stdout
else:
f = file(outfile, "wb")
import texmlwr
try:
f = texmlwr.stream_encoder(f, encoding)
except Exception, e:
print >>sys.stderr, "texml: Can't create encoder: '%s'" % e
sys.exit(5)
#
# Create transformer and run process
#
import handler
h = handler.handler(f)
xml.sax.parse(infile, h)
#
# Ok
#
f.close()
sys.exit(0)
# CLIFS/main.py
# A part of the command line flight simulator.
# Copyright (c) 2014 ks-salutions.
import handler
handle = handler.handler()
def manual_flight():
"""
This function asks the user which direction to fly in and at which speed. I'll probably update handle.py to include this.
"""
print("Welcome to manual flight.\n")
print("Enter a direction.")
dir = input()
print("Now, enter a speed.")
speed = input()
return_value = handle.go(dir, speed)
if return_value == -1:
print("Error: This is not a valid direction.")
main_menu()
def automatic_flight():
"""
This function is essentially the same as the last, with one extra peramitor. Again, I will probably update handle.py.
"""
print("Welcome to the automatic flight system.\n")
print("Enter a direction.")
dir = input()
print("Now, enter a speed.")
def _add_scoket(self, socket):
self._lock.acquire()
if socket not in self._conn_sockets:
conn = connection.connection(socket, handler.handler())
self._conn_sockets[socket] = conn
self._lock.release()
