Exemple #1
0
    def setup_collector(self, args_dict, logging_handler, extra_files):
        """Create and initialize a collector"""
        config_name = None
        if args_dict["photons_app"]["config"] is not sb.NotSpecified:
            config_name = args_dict["photons_app"]["config"].name

        collector = Collector()
        collector.prepare(config_name, args_dict, extra_files=extra_files)
        if "term_colors" in collector.configuration:
            self.setup_logging_theme(logging_handler, colors=collector.configuration["term_colors"])

        return collector
Exemple #2
0
        def collector(self):
            with OverrideLoop(new_loop=False):
                superman = mock.Mock(
                    name="resolvedsuperman",
                    instantiated_name="superman",
                    spec=["instantiated_name"],
                )
                batman = mock.Mock(
                    name="resolvedbatman", instantiated_name="batman", spec=["instantiated_name"]
                )
                vegemite = mock.Mock(
                    name="resolvedvegemite",
                    instantiated_name="vegemite",
                    spec=["instantiated_name"],
                )
                road = mock.Mock(
                    name="resolvedroad", instantiated_name="road", spec=["instantiated_name"]
                )

                collector = Collector()
                collector.prepare(None, {})
                reg = collector.configuration["target_register"]

                HeroTarget = mock.Mock(name="HeroTarget")
                herotarget = Target.FieldSpec().empty_normalise(type="hero")
                reg.register_type("hero", HeroTarget)

                VillianTarget = mock.Mock(name="VillianTarget")
                villiantarget = Target.FieldSpec().empty_normalise(type="villian")
                reg.register_type("villian", VillianTarget)

                InfraTarget = mock.Mock(name="InfraTarget")
                infratarget = Target.FieldSpec().empty_normalise(type="infrastructure")
                reg.register_type("infrastructure", InfraTarget)

                supermancreator = mock.Mock(name="supermancreator", return_value=superman)
                reg.add_target("superman", herotarget, supermancreator)

                batmancreator = mock.Mock(name="batmancreator", return_value=batman)
                reg.add_target("batman", herotarget, batmancreator)

                vegemitecreator = mock.Mock(name="vegemitecreator", return_value=vegemite)
                reg.add_target("vegemite", villiantarget, vegemitecreator)

                roadcreator = mock.Mock(name="roadcreator", return_value=road)
                reg.add_target("road", infratarget, roadcreator)

                yield collector
Exemple #3
0
def library_setup(config_filename="lifx.yml",
                  photons_modules=True,
                  extra_files=None,
                  photons_app_options=None):
    """
    Get us a setup photons Collector instance.

    config_filename
        Optionally provide the filename of configuration to read in and parse

    photons_modules
        If this is set to True then all photons modules in your environment will
        be activated. If it is an array, then only the modules in that array
        will be activated.

        If you only want modules from photons-core then say photons_modules=["core"]

    extra_files
        Optionally provide extra configuration files to load in

    photons_app_options
        Options to instantiate the photons_app object with.

    This function returns :ref:`photons_app_collector`.
    """
    photons_app = photons_app_options if photons_app_options is not None else {}

    def init_addons(adns):
        if "addons" not in photons_app:
            photons_app["addons"] = {}

        if "lifx.photons" not in photons_app["addons"]:
            photons_app["addons"]["lifx.photons"] = adns

    if photons_modules is True:
        init_addons(["__all__"])
    elif type(photons_modules) is str:
        init_addons([photons_modules])
    elif type(photons_modules) is list:
        init_addons(photons_modules)

    collector = Collector()
    collector.prepare(config_filename, {"photons_app": photons_app},
                      extra_files=extra_files)
    collector.configuration["target_register"].add_targets(
        collector.configuration["targets"])
    return collector
Exemple #4
0
# coding: spec

from photons_socket.target import SocketTarget

from photons_app.test_helpers import TestCase
from photons_app.collector import Collector
from photons_app import helpers as hp

from photons_messages import DiscoveryMessages

from textwrap import dedent

describe TestCase, "Addon":
    it "works":
        collector = Collector()
        with hp.a_temp_file() as fle:
            fle.write(dedent("""
            ---

            photons_app:
              addons:
                lifx.photons:
                  - socket

            targets:
              lan:
                type: lan
            """).encode())

            fle.flush()
            collector.prepare(fle.name, {})
Exemple #5
0
from input_algorithms import spec_base as sb
from option_merge_addons import Register
from option_merge import MergedOptions
from input_algorithms.meta import Meta
from contextlib import contextmanager
from option_merge.path import Path
from textwrap import dedent
import pkg_resources
import asyncio
import uuid
import mock
import os

describe TestCase, "Collector":
    it "can be cloned":
        collector = Collector()

        prepare = mock.Mock(name="prepare")
        with hp.a_temp_file() as fle:
            fle.write(dedent("""
            ---

            photons_app:
               artifact: "blah"
               ignored: "an option"

            """).encode())
            fle.close()
            collector.prepare(fle.name, {"one": 2})

            with mock.patch.object(Collector, "prepare", prepare):
Exemple #6
0
def collector():
    with OverrideLoop(new_loop=False):
        collector = Collector()
        collector.prepare(None, {})
        yield collector
Exemple #7
0
from delfick_project.option_merge import MergedOptions
from delfick_project.option_merge.path import Path
from delfick_project.addons import Register
from contextlib import contextmanager
from textwrap import dedent
from unittest import mock
import asyncio
import pytest
import uuid
import os


describe "Collector":

    it "has a shortcut to the photons_app":
        collector = Collector()
        collector.prepare(None, {})
        assert collector.photons_app is collector.configuration["photons_app"]

    it "has a shortcut to resolve a target":
        collector = Collector()
        collector.prepare(None, {}, extra_files=[{"targets": {"lan": {"type": "lan"}}}])

        class Target(dictobj.Spec):
            pass

        collector.configuration["target_register"].register_type("lan", Target.FieldSpec())
        collector.configuration["target_register"].add_targets(collector.configuration["targets"])

        lan = collector.configuration["target_register"].resolve("lan")
        assert collector.resolve_target("lan") is lan
 def collector(s):
     collector = Collector()
     collector.prepare(None, {})
     return collector
Exemple #9
0
                fle.close()

                with open(fle.name) as realfile:
                    args_dict = {
                          "photons_app":
                          { "config": realfile
                          }
                        }

                    app = App()
                    logging_handler = mock.Mock(name="logging_handler")
                    collector = app.setup_collector(args_dict, logging_handler, None)
                return fle.name, args_dict, logging_handler, collector

        it "prepares the collector with the photons_app.config":
            collector = Collector()
            FakeCollector = mock.Mock(name="Collector", return_value=collector)

            original_prepare = Collector.prepare

            def prepare(*args, **kwargs):
                return original_prepare(collector, *args, **kwargs)
            prepare = mock.Mock(name="prepare", side_effect=prepare)

            with mock.patch("photons_app.executor.Collector", FakeCollector):
                with mock.patch.object(Collector, "prepare", prepare):
                    location, args_dict, logging_handler, collector = self.from_config("")

            prepare.assert_called_once_with(location, args_dict, extra_files=None)

        it "gets us the target from chosen_task if we haven't already got a target":