Exemplo n.º 1
0
    def test_experiment_submit_physical(self):
        """ Run experiment_submit physical """

        # Physical tests
        resources = [experiment.exp_resources(
            ['m3-%u.grenoble.iot-lab.info' % i for i in range(1, 6)])]
        experiment.submit_experiment(self.api, 'exp_name', 20, resources,
                                     start_time=314159)

        call_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': 'exp_name',
            'duration': 20,
            'type': 'physical',
            'nodes': [
                'm3-%u.grenoble.iot-lab.info' % num for num in range(1, 6)
            ],
            'reservation': 314159,
            'profileassociations': None,
            'firmwareassociations': None
        }
        self.assertEqual(expected, json.loads(call_dict['new_exp.json']))

        # Try 'print', should return exp_dict
        ret = experiment.submit_experiment(self.api, 'exp_name', 20,
                                           resources, start_time=314159,
                                           print_json=True)
        self.assertEqual(ret.__dict__, expected)
Exemplo n.º 2
0
    def test_experiment_submit_physical(self):
        """ Run experiment_submit physical """

        # Physical tests
        nodes_list = [
            experiment.exp_resources(
                ['m3-%u.grenoble.iot-lab.info' % i for i in range(1, 6)])
        ]
        experiment.submit_experiment(self.api,
                                     'exp_name',
                                     20,
                                     nodes_list,
                                     start_time=314159)

        call_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': 'exp_name',
            'duration': 20,
            'type': 'physical',
            'nodes':
            ['m3-%u.grenoble.iot-lab.info' % num for num in range(1, 6)],
            'reservation': 314159,
            'profileassociations': None,
            'firmwareassociations': None
        }
        self.assertEquals(expected, json.loads(call_dict['new_exp.json']))

        # Try 'print', should return exp_dict
        ret = experiment.submit_experiment(self.api,
                                           'exp_name',
                                           20,
                                           nodes_list,
                                           start_time=314159,
                                           print_json=True)
        self.assertEquals(ret.__dict__, expected)
Exemplo n.º 3
0
    def test_exp_submit_associations(self):
        """Test experiment submission with associations."""
        nodes = ['m3-1.grenoble.iot-lab.info']
        assocs = {'mobility': 'controlled', 'kernel': 'linux'}
        resources = [
            experiment.exp_resources(nodes,
                                     tests.resource_file('firmware.elf'),
                                     None, **assocs),
        ]

        experiment.submit_experiment(self.api, None, 20, resources)
        call_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': None,
            'duration': 20,
            'type': 'physical',
            'nodes': nodes,
            'reservation': None,
            'profileassociations': None,
            'firmwareassociations': [
                {'firmwarename': 'firmware.elf', 'nodes': nodes}],
            'associations': {
                'mobility': [
                    {'mobilityname': 'controlled', 'nodes': nodes}],
                'kernel': [
                    {'kernelname': 'linux', 'nodes': nodes}],
            },
            'siteassociations': None,
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, json.loads(call_dict['new_exp.json']))
Exemplo n.º 4
0
    def test_exp_submit_associations(self):
        """Test experiment submission with associations."""
        nodes = ['m3-1.grenoble.iot-lab.info']
        assocs = {'mobility': 'controlled', 'kernel': 'linux'}
        resources = [
            experiment.exp_resources(nodes,
                                     tests.resource_file('firmware.elf'),
                                     None, **assocs),
        ]

        experiment.submit_experiment(self.api, None, 20, resources)
        call_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': None,
            'duration': 20,
            'type': 'physical',
            'nodes': nodes,
            'reservation': None,
            'profileassociations': None,
            'firmwareassociations': [
                {'firmwarename': 'firmware.elf', 'nodes': nodes}],
            'associations': {
                'mobility': [
                    {'mobilityname': 'controlled', 'nodes': nodes}],
                'kernel': [
                    {'kernelname': 'linux', 'nodes': nodes}],
            },
            'siteassociations': None,
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, json.loads(call_dict['new_exp.json']))
Exemplo n.º 5
0
 def test_exp_physical_new_types(self):
     """Test submiting physical experiments with 'new' nodes types."""
     resources = [
         experiment.exp_resources(['custom-1.grenoble.iot-lab.info']),
         experiment.exp_resources(['berlin-1.berlin.iot-lab.info']),
     ]
     experiment.submit_experiment(self.api, None, 20, resources)
     self.assertEqual(1, self.api.submit_experiment.call_count)
Exemplo n.º 6
0
 def test_exp_physical_new_types(self):
     """Test submiting physical experiments with 'new' nodes types."""
     resources = [
         experiment.exp_resources(['custom-1.grenoble.iot-lab.info']),
         experiment.exp_resources(['berlin-1.berlin.iot-lab.info']),
     ]
     experiment.submit_experiment(self.api, None, 20, resources)
     self.assertEqual(1, self.api.submit_experiment.call_count)
Exemplo n.º 7
0
 def test_exp_alias_new_types(self):
     """Test submiting alias experiments with 'new' nodes types."""
     resources = [
         experiment.exp_resources(
             experiment.AliasNodes(1, 'berlin', 'des:wifi-cc1100')),
         experiment.exp_resources(
             experiment.AliasNodes(1, 'grenoble', 'custom:leonardo:')),
     ]
     experiment.submit_experiment(self.api, None, 20, resources)
     self.assertEqual(1, self.api.submit_experiment.call_count)
Exemplo n.º 8
0
 def test_exp_alias_new_types(self):
     """Test submiting alias experiments with 'new' nodes types."""
     resources = [
         experiment.exp_resources(
             experiment.AliasNodes(1, 'berlin', 'des:wifi-cc1100')),
         experiment.exp_resources(
             experiment.AliasNodes(1, 'grenoble', 'custom:leonardo:')),
     ]
     experiment.submit_experiment(self.api, None, 20, resources)
     self.assertEqual(1, self.api.submit_experiment.call_count)
Exemplo n.º 9
0
    def test_experiment_submit_duplicated_basenames(self):
        """ Run experiment_submit physical """

        # Physical tests
        resources = [
            experiment.exp_resources(['m3-1.grenoble.iot-lab.info'],
                                     tests.resource_file('firmware.elf')),
            experiment.exp_resources(
                ['m3-2.grenoble.iot-lab.info'],
                tests.resource_file('other/firmware.elf')),
        ]
        experiment.submit_experiment(self.api,
                                     'exp_name',
                                     20,
                                     resources,
                                     start_time=314159)

        call_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name':
            'exp_name',
            'duration':
            20,
            'type':
            'physical',
            'nodes': [
                'm3-1.grenoble.iot-lab.info',
                'm3-2.grenoble.iot-lab.info',
            ],
            'reservation':
            314159,
            'profileassociations':
            None,
            'firmwareassociations': [
                {
                    'firmwarename':
                    'e77d9b8dcb84d1fcd21187b03eac74f1_firmware.elf',
                    'nodes': ['m3-2.grenoble.iot-lab.info']
                },
                {
                    'firmwarename': 'firmware.elf',
                    'nodes': ['m3-1.grenoble.iot-lab.info']
                },
            ],
            'associations':
            None,
            'siteassociations':
            None,
            'profiles':
            None,
            'mobilities':
            None,
        }

        self.assertEqual(expected, json.loads(call_dict['new_exp.json']))
Exemplo n.º 10
0
    def test_experiment_submit_alias(self):
        """ Run experiment_submit alias """
        # Alias tests
        resources = [
            experiment.exp_resources(
                experiment.AliasNodes(1, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware.elf'), 'profile1'),
            experiment.exp_resources(
                experiment.AliasNodes(2, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware.elf'), 'profile1'),
            experiment.exp_resources(
                experiment.AliasNodes(4, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware_2.elf'), 'profile2'),
        ]

        experiment.submit_experiment(self.api, None, 20, resources)
        files_dict = self.api.submit_experiment.call_args[0][0]
        exp_desc = json.loads(files_dict['new_exp.json'])
        expected = {
            'name': None,
            'duration': 20,
            'type': 'alias',
            'nodes': [
                {"alias": '1', "nbnodes": 1, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
                {"alias": '2', "nbnodes": 2, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
                {"alias": '3', "nbnodes": 4, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
            ],
            'reservation': None,
            'profileassociations': [
                {'profilename': 'profile1', 'nodes': ['1', '2']},
                {'profilename': 'profile2', 'nodes': ['3']},
            ],
            'firmwareassociations': [
                {'firmwarename': 'firmware.elf', 'nodes': ['1', '2']},
                {'firmwarename': 'firmware_2.elf', 'nodes': ['3']}
            ],
            'associations': None,
            'siteassociations': None,
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, exp_desc)
        self.assertTrue('firmware.elf' in files_dict)
Exemplo n.º 11
0
    def test_experiment_submit_alias(self):
        """ Run experiment_submit alias """
        # Alias tests
        resources = [
            experiment.exp_resources(
                experiment.AliasNodes(1, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware.elf'), 'profile1'),
            experiment.exp_resources(
                experiment.AliasNodes(2, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware.elf'), 'profile1'),
            experiment.exp_resources(
                experiment.AliasNodes(4, 'grenoble', 'm3:at86rf231', False),
                tests.resource_file('firmware_2.elf'), 'profile2'),
        ]

        experiment.submit_experiment(self.api, None, 20, resources)
        files_dict = self.api.submit_experiment.call_args[0][0]
        exp_desc = json.loads(files_dict['new_exp.json'])
        expected = {
            'name': None,
            'duration': 20,
            'type': 'alias',
            'nodes': [
                {"alias": '1', "nbnodes": 1, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
                {"alias": '2', "nbnodes": 2, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
                {"alias": '3', "nbnodes": 4, "properties": {
                    "archi": "m3:at86rf231", "site": "grenoble",
                    "mobile": False
                }},
            ],
            'reservation': None,
            'profileassociations': [
                {'profilename': 'profile1', 'nodes': ['1', '2']},
                {'profilename': 'profile2', 'nodes': ['3']},
            ],
            'firmwareassociations': [
                {'firmwarename': 'firmware.elf', 'nodes': ['1', '2']},
                {'firmwarename': 'firmware_2.elf', 'nodes': ['3']}
            ],
            'associations': None,
            'siteassociations': None,
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, exp_desc)
        self.assertTrue('firmware.elf' in files_dict)
Exemplo n.º 12
0
def submit_experiment(testbed_name, board, firmware, duration):
    """
    Reserve nodes in the given site.
    The function uses the json experiment file corresponding to the site.
    :param str firmware: the name of the firmware as it is in the code/firmware/ folder
    :param str board: the type of board (ex: m3)
    :param str testbed_name: The name of the testbed (ex: grenoble)
    :param int duration: The duration of the experiment in minutes
    :return: The id of the experiment
    """

    # use the file created by auth-cli command
    usr, pwd = iotlab.get_user_credentials()

    # authenticate through the REST interface
    api = iotlab.rest.Api(usr, pwd)

    # load the experiment
    tb_file = open("{0}states.json".format(METAS_PATH))
    tb_json = json.load(tb_file)
    nodes = [x for x in tb_json[testbed_name] if board in x]
    firmware = FIRMWARE_PATH + firmware
    profile = "mercator"
    resources = [experiment.exp_resources(nodes, firmware, profile)]

    # submit experiment
    logconsole.info("Submitting experiment.")
    expid = experiment.submit_experiment(api, "mercatorExp", duration,
                                         resources)["id"]

    logconsole.info("Experiment submited with id: %u", expid)
    logconsole.info("Waiting for experiment to be running.")
    experiment.wait_experiment(api, expid)

    return expid
Exemplo n.º 13
0
def launch_experiment(deployment_site, number_of_nodes, experiment_time,
                      corridor):
    settings = settings_reader.SettingsReader(deployment_site)

    ids_text = extract_nodes_ids(str(settings.get_parameter(corridor)))
    nodes_ids = []
    for item in ids_text:
        id_begin, id_end = (int(x) for x in item.split("-"))
        nodes_ids.extend(np.arange(id_begin, id_end + 1, 1).tolist())

    json_data = json.loads(
        experiment.info_experiment(request, site=deployment_site))
    nodes_to_reserve = select_candidates(json_data, nodes_ids, number_of_nodes,
                                         deployment_site)

    resources = experiment.exp_resources(nodes_to_reserve)
    experiment_id = json.loads(
        experiment.submit_experiment(
            request, '', experiment_time + int(
                settings_reader.SettingsReader('experiment').get_parameter(
                    "extra_time")), resources))["id"]

    print_log("Starting new Experiment ({})".format(experiment_id))
    print_log("Selected nodes: {}".format(" ".join(nodes_to_reserve)),
              header=False)

    experiment.wait_experiment(request, experiment_id)
    return experiment_id
Exemplo n.º 14
0
def submit_experiment_a8(api, duration, nb_nodes,
                         site="grenoble",
                         name="test_exp_A8"):
    resources = exp_resources_from_str(
                 "{},archi=a8:at86rf231+site={}".format(nb_nodes, site))
    exp = experiment.submit_experiment(api, name, duration, [resources])
    exp_id = exp['id']
    return exp_id
Exemplo n.º 15
0
def submit_experiment_parser(opts):
    """ Parse namespace 'opts' and execute requested 'submit' command """
    user, passwd = auth.get_user_credentials(opts.username, opts.password)
    api = rest.Api(user, passwd)

    return experiment.submit_experiment(api, opts.name, opts.duration,
                                        opts.nodes_list, opts.reservation,
                                        opts.print_json)
Exemplo n.º 16
0
def submit_experiment_parser(opts):
    """ Parse namespace 'opts' and execute requested 'submit' command """
    user, passwd = auth.get_user_credentials(opts.username, opts.password)
    api = rest.Api(user, passwd)

    return experiment.submit_experiment(api, opts.name, opts.duration,
                                        opts.nodes_list, opts.reservation,
                                        opts.print_json, opts.site_association)
Exemplo n.º 17
0
def test_submit_experiment_a8_physical(api):
    resources = exp_resources_from_str("grenoble,a8,1-2")
    name = "test_exp_A8"
    duration = 2
    exp = experiment.submit_experiment(api, name, duration, [resources])
    exp_id = exp['id']
    experiment.wait_experiment(api, exp_id)
    state = experiment.get_experiment(api, exp_id, 'state')
    assert state['state'] == "Running"
Exemplo n.º 18
0
def test_submit_experiment_a8_logical(api, exp):
    name = "test_exp_A8"
    duration = 2
    resources = exp_resources_from_str("2,archi=a8:at86rf231+site=grenoble")
    ret = experiment.submit_experiment(api, name, duration, [resources])
    exp.id = ret['id']
    exp_id = exp.id
    experiment.wait_experiment(api, exp_id)
    state = experiment.get_experiment(api, exp_id, 'state')
    assert state['state'] == "Running"
Exemplo n.º 19
0
    def submit_exp(self, name, duration):
        """ Submit experiment with name and duration """
        fabric.utils.puts("submit_exp")
        self.nodes = self._get_nodes_list(self.site, self.archi)
        if not self.nodes:
            raise ValueError("Empty nodes list")
        firmware = None if self.archi == 'a8:at86rf231' else self.firmware

        resources = [experiment.exp_resources(self.nodes, firmware)]
        self.exp_id = experiment.submit_experiment(self.api, name, duration,
                                                   resources)["id"]

        fabric.utils.puts("Exp-id:%d" % self.exp_id)
Exemplo n.º 20
0
    def submit_exp(self, name, duration):
        """ Submit experiment with name and duration """
        fabric.utils.puts("submit_exp")
        self.nodes = self._get_nodes_list(self.site, self.archi)
        if not self.nodes:
            raise ValueError("Empty nodes list")
        firmware = None if self.archi == 'a8:at86rf231' else self.firmware

        resources = [experiment.exp_resources(self.nodes, firmware)]
        self.exp_id = experiment.submit_experiment(self.api, name, duration,
                                                   resources)["id"]

        fabric.utils.puts("Exp-id:%d" % self.exp_id)
Exemplo n.º 21
0
 def _submit(self, site, duration):
     """Submit an experiment with required nodes"""
     api = Api(*self.user_credentials())
     resources = []
     for ctrl in self.ctrls:
         if ctrl.env.get('IOTLAB_NODE') is not None:
             resources.append(exp_resources([ctrl.env.get('IOTLAB_NODE')]))
         elif ctrl.board() is not None:
             board = IoTLABExperiment._archi_from_board(ctrl.board())
             alias = AliasNodes(1, site, board)
             resources.append(exp_resources(alias))
         else:
             raise ValueError("neither BOARD or IOTLAB_NODE are set")
     return submit_experiment(api, self.name, duration, resources)['id']
Exemplo n.º 22
0
    def submit(self):
        """"
        Submit an experiment
        using class attribute for parametrization :
         self.nodename
         self.profile
         self.time
        """
        qexp = experiment.submit_experiment(
            self.api, 'test', self.time, [{'firmware': None,
                                           'profile': self.profile,
                                           'type': 'physical',
                                           'nodes': [self.nodename]}])

        self.idexpe = qexp['id']
Exemplo n.º 23
0
    def submit(self):
        """"
        Submit an experiment
        using class attribute for parametrization :
         self.nodename
         self.profile
         self.time
        """
        qexp = experiment.submit_experiment(self.api, 'test', self.time,
                                            [{
                                                'firmware': None,
                                                'profile': self.profile,
                                                'type': 'physical',
                                                'nodes': [self.nodename]
                                            }])

        self.idexpe = qexp['id']
def submit_experiment(args):
    """
    Reserve nodes in the given site.
    The function uses the json experiment file corresponding to the site.
    :param str firmware: the name of the firmware as it is in the code/firmware/ folder
    :param str board: the type of board (ex: m3)
    :param str testbed: The name of the testbed (ex: grenoble)
    :param int duration: The duration of the experiment in minutes
    :param int nbnodes: The number of nodes to use
    :return: The id of the experiment
    """

    # use the file created by auth-cli command
    usr, pwd    = iotlab.get_user_credentials()

    # authenticate through the REST interface
    api         = iotlab.rest.Api(usr, pwd)

    # load the experiment
    firmware    = FIRMWARE_PATH + args.firmware
    profile     = "mercator"
    if args.nbnodes != 0:
        if args.board == "m3":
            args.board = "m3:at86rf231"
        nodes = experiment.AliasNodes(args.nbnodes, args.testbed, args.board)
    else:
        tb_file = open("{0}states.json".format(METAS_PATH))
        tb_json = json.load(tb_file)
        nodes = [x for x in tb_json[args.testbed] if args.board in x]
    resources = [experiment.exp_resources(nodes, firmware, profile)]

    # submit experiment
    logconsole.info("Submitting experiment.")
    expid       = experiment.submit_experiment(
                    api, "mercatorExp", args.duration,
                    resources)["id"]

    logconsole.info("Experiment submited with id: %u", expid)
    logconsole.info("Waiting for experiment to be running.")
    experiment.wait_experiment(api, expid)

    return expid
Exemplo n.º 25
0
def push_iotlab(name):
    experiment_path = pj(EXPERIMENT_FOLDER, name)
    results_folder = pj(experiment_path, "results", "iotlab")
    if not os.path.exists(results_folder):
        os.makedirs(results_folder)

    # gets user password from credentials file None, None
    user, passwd = iotlabcli.get_user_credentials()
    api = iotlabcli.Api(user, passwd)

    # describe the resources
    resources = None
    with open(pj(experiment_path, "iotlab.json")) as f:
        config = json.loads(f.read())
        resources = [experiment.exp_resources(**c) for c in config]

    print(resources)
    # actually submit the experiment
    exp_id = None
    # We move to the folder to have a portable iotlab.json
    with lcd(experiment_path):
        exp_res = experiment.submit_experiment(
            api, 'dummy_experiment', 1, resources)
        exp_id = exp_wres["id"]
        with open("results/iotlab/iotlab.json", "w") as f:
            f.write(json.dumps({"id": exp_id}))

    # get the content
    print("Exp submited with id: %u" % exp_id)

    run("experiment-cli wait -i %d" % exp_id)

    with open(pj(results_folder, "serial.log"), 'w') as f:
        run("./iot-lab/tools_and_scripts/serial_aggregator.py -i %d" % exp_id,
            stdout=f)
    print("Written serial logs to %s" % pj(results_folder, "serial.log"))
Exemplo n.º 26
0
    def test_exp_submit_site_association(self):
        """Test experiment submission with site associations."""
        nodes = ['m3-1.grenoble.iot-lab.info', 'a8-1.strasbourg.iot-lab.info']
        resources = [experiment.exp_resources(nodes)]

        site_assocs = [
            experiment.site_association(
                'grenoble',
                script=tests.resource_file('script.sh'),
                ipv6='aaaa::/64',
            ),
            experiment.site_association(
                'strasbourg',
                script=tests.resource_file('script_2.sh'),
                scriptconfig=tests.resource_file('scriptconfig'),
            ),
        ]

        experiment.submit_experiment(self.api, None, 20, resources,
                                     sites_assocs=site_assocs)
        files_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': None,
            'duration': 20,
            'type': 'physical',
            'nodes': nodes,
            'reservation': None,
            'profileassociations': None,
            'firmwareassociations': None,
            'associations': None,
            'siteassociations': {
                'script': [
                    {
                        'scriptname': 'script.sh',
                        'sites': ['grenoble']
                    },
                    {
                        'scriptname': 'script_2.sh',
                        'sites': ['strasbourg']
                    },
                ],
                'scriptconfig': [
                    {
                        'scriptconfigname': 'scriptconfig',
                        'sites': ['strasbourg']
                    },
                ],
                'ipv6': [
                    {
                        'ipv6name': 'aaaa::/64',
                        'sites': ['grenoble']
                    },
                ],
            },
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, json.loads(files_dict['new_exp.json']))
        self.assertEqual(files_dict['script.sh'], SCRIPTS['script.sh'])
        self.assertEqual(files_dict['script_2.sh'], SCRIPTS['script_2.sh'])
        self.assertEqual(files_dict['scriptconfig'],
                         SCRIPTCONFIG['scriptconfig'])
Exemplo n.º 27
0
def _submit_exp(api, name, duration, resources):
    """ Submit experiment """
    return experiment.submit_experiment(api, name, duration,
                                        resources)['id']
Exemplo n.º 28
0
    def test_exp_submit_site_association(self):
        """Test experiment submission with site associations."""
        nodes = ['m3-1.grenoble.iot-lab.info', 'a8-1.strasbourg.iot-lab.info']
        resources = [experiment.exp_resources(nodes)]

        site_assocs = [
            experiment.site_association(
                'grenoble',
                script=tests.resource_file('script.sh'),
                ipv6='aaaa::/64',
            ),
            experiment.site_association(
                'strasbourg',
                script=tests.resource_file('script_2.sh'),
                scriptconfig=tests.resource_file('scriptconfig'),
            ),
        ]

        experiment.submit_experiment(self.api, None, 20, resources,
                                     sites_assocs=site_assocs)
        files_dict = self.api.submit_experiment.call_args[0][0]
        expected = {
            'name': None,
            'duration': 20,
            'type': 'physical',
            'nodes': nodes,
            'reservation': None,
            'profileassociations': None,
            'firmwareassociations': None,
            'associations': None,
            'siteassociations': {
                'script': [
                    {
                        'scriptname': 'script.sh',
                        'sites': ['grenoble']
                    },
                    {
                        'scriptname': 'script_2.sh',
                        'sites': ['strasbourg']
                    },
                ],
                'scriptconfig': [
                    {
                        'scriptconfigname': 'scriptconfig',
                        'sites': ['strasbourg']
                    },
                ],
                'ipv6': [
                    {
                        'ipv6name': 'aaaa::/64',
                        'sites': ['grenoble']
                    },
                ],
            },
            'profiles': None,
            'mobilities': None,
        }
        self.assertEqual(expected, json.loads(files_dict['new_exp.json']))
        self.assertEqual(files_dict['script.sh'], SCRIPTS['script.sh'])
        self.assertEqual(files_dict['script_2.sh'], SCRIPTS['script_2.sh'])
        self.assertEqual(files_dict['scriptconfig'],
                         SCRIPTCONFIG['scriptconfig'])