diff --git a/tests/modules/test_raspberrypi.py b/tests/modules/test_raspberrypi.py
index d9fad53d9876299450a947f4deb4f1d709a8677e..238e17e73bd79b140091f455529c8947f17b76c6 100644
--- a/tests/modules/test_raspberrypi.py
+++ b/tests/modules/test_raspberrypi.py
@@ -2,6 +2,8 @@ import pytest
 import time
 from pi_mqtt_gpio.modules import raspberrypi, PinDirection, PinPullup, InterruptEdge
 
+pytestmark = pytest.mark.hw_raspberrypi
+
 '''
 Definition of wired connected GPIOs
 You may connect them with a 10kOhm resistor
@@ -24,7 +26,7 @@ interrupt_count = 0
 test_handle = 0
 
 @pytest.fixture(autouse=True)
-def test_raspberrypi_setup_teardown():
+def fix_raspberrypi_setup_teardown():
     # Code that will run before your test, for example:
     global gpio
     gpio = raspberrypi.GPIO("")
diff --git a/tests/test_server_gpio_interrupt.py b/tests/test_server_gpio_interrupt.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae38d33025cf4094b96dac7cfaf512b3cc975267
--- /dev/null
+++ b/tests/test_server_gpio_interrupt.py
@@ -0,0 +1,13 @@
+import mock
+import pytest
+
+from pi_mqtt_gpio import server
+
+@mock.patch("pkg_resources.WorkingSet")
+def test_imr_no_attribute(mock_ws):
+    """
+    Should not bother looking up what's installed when there's no requirements.
+    """
+    module = object()
+    server.install_missing_requirements(module)
+    mock_ws.assert_not_called()
diff --git a/tests/test_yaml_validation_modules_raspberrypi.py b/tests/test_yaml_validation_modules_raspberrypi.py
new file mode 100644
index 0000000000000000000000000000000000000000..c1fb7f81eacd0084bdcc1da76f64475e7be46709
--- /dev/null
+++ b/tests/test_yaml_validation_modules_raspberrypi.py
@@ -0,0 +1,364 @@
+import pytest
+
+from importlib import import_module
+import cerberus
+import yaml
+import copy
+
+from pi_mqtt_gpio import CONFIG_SCHEMA
+from pi_mqtt_gpio.modules import BASE_SCHEMA
+
+gpio_module = import_module("pi_mqtt_gpio.modules.raspberrypi")
+
+# Doesn't need to be a deep copy because we won't modify the base
+# validation rules, just add more of them.
+module_config_schema_input = CONFIG_SCHEMA.copy()
+module_config_schema_input = {"digital_inputs" : module_config_schema_input["digital_inputs"]}
+module_config_schema_input.update(
+    getattr(gpio_module, "CONFIG_SCHEMA", {}))
+#print yaml.dump(module_config_schema_input)
+module_validator_input = cerberus.Validator(module_config_schema_input)
+
+module_config_schema_output = CONFIG_SCHEMA.copy()
+module_config_schema_output = {"digital_outputs" : module_config_schema_output["digital_outputs"]}
+module_config_schema_output.update(
+    getattr(gpio_module, "CONFIG_SCHEMA", {}))
+#print yaml.dump(module_config_schema_output)
+module_validator_output = cerberus.Validator(module_config_schema_output)
+
+digital_inputs = {}
+digital_outputs = {}
+config = {}
+with open("config.example.yml") as f:
+    config = yaml.load(f)
+
+class ModuleConfigInvalid(Exception):
+    def __init__(self, errors, *args, **kwargs):
+        self.errors = errors
+        super(ModuleConfigInvalid, self).__init__(*args, **kwargs)
+
+
+@pytest.fixture(autouse=True)
+def test_raspberrypi_setup_teardown():
+    # reset the digital_inputs, digital_outputs before each test
+    global digital_inputs
+    global digital_outputs
+    # here we need a deep copy, because modifications from previous test
+    # shall not bother the following tests
+    config_copy = copy.deepcopy(config) #config.deepcopy()
+    digital_inputs = {"digital_inputs" : config_copy["digital_inputs"]}
+    digital_outputs = {"digital_outputs" : config_copy["digital_outputs"]}
+    
+    # A test function will be run at this point
+    yield
+
+    # Code that will run after your test, for example:
+    yaml.dump(module_validator_input.errors)
+    yaml.dump(module_validator_output.errors)
+
+"""
+Tests for raspberry pi digital digital_inputs
+"""
+def test_yaml_validation_modules_raspberrypi_digital_input_good():
+    # test a valid digital_inputs configuration for digital_inputs
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_unknown_key():
+    # test a valid digital_inputs configuration for digital_inputs
+    digital_inputs["digital_inputs"][0]['unknown'] = "key"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_module_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['module']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_module_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['module'] = 21
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+        
+def test_yaml_validation_modules_raspberrypi_digital_input_name_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['name']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_name_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['name'] = 3.1415
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+        
+def test_yaml_validation_modules_raspberrypi_digital_input_pin_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['pin']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_pin_no_number():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['pin'] = "12"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_on_payload_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['on_payload']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_on_payload_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['on_payload'] = True
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_off_payload_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['off_payload']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_off_payload_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['off_payload'] = 1
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_pullup_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['pullup']
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_pullup_no_boolean():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['pullup'] = "off"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_pulldown_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_inputs["digital_inputs"][0]['pulldown']
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_pulldown_no_boolean():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['pulldown'] = 1
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_retain_optional():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['retain'] = True
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_retain_no_boolean():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['retain'] = "no"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_interrupt_empty():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_inputs["digital_inputs"][0]['interrupt'] = ""
+    digital_inputs["digital_inputs"][1]['interrupt'] = None
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_input.validate(digital_inputs):
+            yaml.dump(module_validator_input.errors)
+            raise ModuleConfigInvalid(module_validator_input.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_input_interrupt_valid_values():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+
+    # digital_inputs["digital_inputs"][1]['interrupt'] = "rising" #  thats already in example
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+    digital_inputs["digital_inputs"][1]['interrupt'] = "falling"
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+
+    digital_inputs["digital_inputs"][1]['interrupt'] = "both"
+    if not module_validator_input.validate(digital_inputs):
+        yaml.dump(module_validator_input.errors)
+        raise ModuleConfigInvalid(module_validator_input.errors)
+"""
+Tests for raspberry pi digital digital_outputs
+"""
+def test_yaml_validation_modules_raspberrypi_digital_output_good():
+    # test a valid digital_outputs configuration for digital_outputs
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_module_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_outputs["digital_outputs"][0]['module']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_module_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['module'] = 21
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+        
+def test_yaml_validation_modules_raspberrypi_digital_output_name_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_outputs["digital_outputs"][0]['name']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_name_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['name'] = 3.1415
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+        
+def test_yaml_validation_modules_raspberrypi_digital_output_pin_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_outputs["digital_outputs"][0]['pin']
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_pin_no_number():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['pin'] = "12"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_on_payload_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_outputs["digital_outputs"][0]['on_payload']
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_on_payload_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['on_payload'] = True
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_off_payload_missing():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    del digital_outputs["digital_outputs"][0]['off_payload']
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_off_payload_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['off_payload'] = 1
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_inverted_optional():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['inverted'] = True
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_inverted_no_boolean():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['inverted'] = "off"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_initial_optional_low():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['initial'] = "low"
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_initial_optional_high():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['initial'] = "high"
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_initial_no_string():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['initial'] = 1
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_retain_optional():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['retain'] = True
+    if not module_validator_output.validate(digital_outputs):
+        yaml.dump(module_validator_output.errors)
+        raise ModuleConfigInvalid(module_validator_output.errors)
+
+def test_yaml_validation_modules_raspberrypi_digital_output_retain_no_boolean():
+    # setup gpio TEST_RASPBERRYPI_GPIO_SET_GET_OUTPUT as output
+    digital_outputs["digital_outputs"][0]['retain'] = "no"
+    with pytest.raises(ModuleConfigInvalid):
+        if not module_validator_output.validate(digital_outputs):
+            yaml.dump(module_validator_output.errors)
+            raise ModuleConfigInvalid(module_validator_output.errors)
diff --git a/tests_integration/test_connect.py b/tests_integration/test_connect.py
new file mode 100644
index 0000000000000000000000000000000000000000..d191d9469cacc5eb7bab699d4eb7371a447fef83
--- /dev/null
+++ b/tests_integration/test_connect.py
@@ -0,0 +1,47 @@
+import pytest
+import time
+import argparse
+
+import paho.mqtt.client as mqtt
+from pi_mqtt_gpio import server
+
+pytestmark = pytest.mark.mqtt
+
+
+receive = []
+
+# The callback for when the client receives a CONNACK response from the server.
+def on_connect(client, userdata, flags, rc):
+    print("Connected with result code "+str(rc))
+
+    # Subscribing in on_connect() means that if we lose the connection and
+    # reconnect then subscriptions will be renewed.
+    client.subscribe("$SYS/#")
+
+# The callback for when a PUBLISH message is received from the server.
+def on_message(client, userdata, msg):
+    print(msg.topic+" "+str(msg.payload))
+
+client = mqtt.Client()
+client.on_connect = on_connect
+client.on_message = on_message
+
+@pytest.fixture(autouse=True)
+def test_raspberrypi_setup_teardown():
+    # reset the digital_inputs, digital_outputs before each test
+    client.reinitialise()
+    client.connect("localhost", 1883, 60)
+    time.sleep(0.5) # wait for receivs and delete them.
+    del receive[:]
+
+    # A test function will be run at this point
+    yield
+
+    # Code that will run after your test, for example:
+
+def test_connect():
+    # setup outputs and inputs for interrupt tests for rising edges
+    args = argparse.Namespace()
+    args.config = "config.example.yml"
+    server.main(args)
+#client.loop_forever()
diff --git a/tests_integration/test_gpio_interrupt.py b/tests_integration/test_gpio_interrupt.py
new file mode 100644
index 0000000000000000000000000000000000000000..d9437b5b584a759dbef1086078c1b00b3aa89f0a
--- /dev/null
+++ b/tests_integration/test_gpio_interrupt.py
@@ -0,0 +1,61 @@
+import mock
+import pytest
+
+from pi_mqtt_gpio import server
+from pi_mqtt_gpio.server import GPIO_INTERRUPT_LOOKUP
+from pi_mqtt_gpio.modules.stdio import GPIO
+
+@pytest.fixture
+def fix_interrupt():
+    GPIO_INTERRUPT_LOOKUP.clear()
+    yield fix_interrupt
+
+@mock.patch("pi_mqtt_gpio.modules.stdio.GPIO")
+def test_server_gpio_configure_gpio_module(mock_std_gpio):
+    """
+    Should not bother looking up what's installed when there's no requirements.
+    """
+    gpio_config = {"name": "dev", "module": "stdio", "cleanup": False}
+    server.configure_gpio_module(gpio_config)
+    mock_std_gpio.assert_called()
+
+@mock.patch("pi_mqtt_gpio.modules.stdio.GPIO")
+def test_server_gpio_initialise_digital_input(mock_std_gpio):
+    """
+    Should not bother looking up what's installed when there's no requirements.
+    """
+    in_conf = {"name": "button", "module": "dev", "pin": 21, "on_payload": "ON",
+               "off_payload": "OFF", "pullup": False, "pulldown": True,
+               "interrupt": "none", "bouncetime": 100}
+    server.initialise_digital_input(in_conf, mock_std_gpio)
+    mock_std_gpio.setup_pin.assert_called()
+    mock_std_gpio.setup_interrupt.assert_not_called()
+
+@mock.patch("pi_mqtt_gpio.modules.stdio.GPIO")
+def test_server_gpio_initialise_digital_input_interrupt(mock_std_gpio, fix_interrupt):
+    """	
+    Should not bother looking up what's installed when there's no requirements.
+    """
+    in_conf = {"name": "button", "module": "dev", "pin": 21, "on_payload": "ON",
+               "off_payload": "OFF", "pullup": False, "pulldown": True,
+               "interrupt": "rising", "bouncetime": 100}
+    server.initialise_digital_input(in_conf, mock_std_gpio)
+    mock_std_gpio.setup_pin.assert_called()
+    mock_std_gpio.setup_interrupt.assert_called()
+    assert GPIO_INTERRUPT_LOOKUP["dev"][21] == in_conf
+    
+@mock.patch("pi_mqtt_gpio.server.client")
+def test_server_gpio_initialise_digital_input_interrupt_trigger(mock_client, fix_interrupt):
+    """
+    Should not bother looking up what's installed when there's no requirements.
+    """
+    in_conf = {"name": "button", "module": "dev", "pin": 21, "on_payload": "ON",
+               "off_payload": "OFF", "pullup": False, "pulldown": True,
+               "retain" : False, "interrupt": "rising", "bouncetime": 100}
+    GPIO_INTERRUPT_LOOKUP["dev"] = {}
+    GPIO_INTERRUPT_LOOKUP["dev"][21] = in_conf
+    server.gpio_interrupt_callback("dev", 21, True)
+    mock_client.publish.assert_called_once_with(
+        "%s/%s/%s" % (server.topic_prefix, server.OUTPUT_TOPIC, in_conf["name"]),
+        payload=True,
+        retain=in_conf["retain"])
diff --git a/tests_integration/test_tst.py b/tests_integration/test_tst.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b4e9f7f6d9c352d5b421e98c67b3d70bfe96d70
--- /dev/null
+++ b/tests_integration/test_tst.py
@@ -0,0 +1,23 @@
+import mock
+import pytest
+
+@pytest.fixture(scope="module", autouse=True)
+def fix_module():
+    print("setup module")
+    yield fix_module  # provide the fixture value
+    print("teardown module")
+
+@pytest.fixture(autouse=True)
+def fix_fkt():
+    print("setup fkt")
+    yield fix_module  # provide the fixture value
+    print("teardown fkt")
+
+def test_1():
+    print("test 1")
+
+def test_2():
+    print("test 2")
+
+def test_3():
+    print("test 3")
diff --git a/tox.ini b/tox.ini
index c416f7561937aba11f256f4d8b455fa50bd156f9..db6c6015cd0bcbd68c15e219bf215c8055d52751 100644
--- a/tox.ini
+++ b/tox.ini
@@ -13,7 +13,7 @@ whitelist_externals =
     make
 commands =
     make schema
-    py.test tests/test_server.py tests/modules/test_stdio.py
+    py.test -m "not hw_raspberrypi and not mqtt"
 
 [testenv:flake8]
 commands =