def test_double_env_var(self, monkeypatch):
        expected_token = 'app_id|app_secret'

        monkeypatch.setenv(te.TX_APP_ID, 'app_id')
        monkeypatch.setenv(te.TX_APP_SECRET, 'app_secret')
        access_token.init()
        self.verify_token(expected_token)
    def test_explicit_token_file(self):
        expected_token = 'app_id|app_secret'
        file_contents = 'app_id|app_secret'

        with nested(
            patch('pytx.access_token._find_token_file', return_value=None),
            patch('pytx.access_token._read_token_file', return_value=file_contents)
        ):
            access_token.init(token_file='/foobar/mocked/away')
            self.verify_token(expected_token)
    def validate_config(self):
        super(ThreatExchangeConnector, self).validate_config()
        self.check_required_options(["tx_app_id", "tx_secret_key", "carbonblack_server_token"])

        self.bridge_options["listener_port"] = self.get_config_integer("listener_port", 6120)
        self.bridge_options["feed_host"] = self.get_config_string("feed_host", "127.0.0.1")
        self.bridge_options["listener_address"] = self.get_config_string("listener_address", "0.0.0.0")

        self.bridge_auth["app_id"] = self.get_config_string("tx_app_id")
        self.bridge_auth["secret_key"] = self.get_config_string("tx_secret_key")
        access_token.init(self.bridge_auth["app_id"], self.bridge_auth["secret_key"])

        ioc_types = self.get_config_string("tx_ioc_types", None)
        if not ioc_types or len(ioc_types.strip()) == 0:
            ioc_types = processing_engines.ALL_INDICATOR_TYPES
        ioc_types = ioc_types.split(',')
        self.bridge_options["ioc_types"] = []

        for ioc_type in ioc_types:
            if ioc_type not in processing_engines.INDICATOR_PROCESSORS:
                self.logger.warning("%s is not a valid IOC type, ignoring" % ioc_type)
            else:
                self.bridge_options["ioc_types"].append(ioc_type)

        self.bridge_options["historical_days"] = self.get_config_integer("tx_historical_days", 7)

        # retrieve once a day by default
        self.bridge_options["feed_retrieval_minutes"] = self.get_config_integer("feed_retrieval_minutes", 120)

        self.bridge_options["minimum_severity"] = self.get_config_string("tx_minimum_severity", "WARNING")
        self.bridge_options["minimum_confidence"] = int(self.get_config_string("tx_minimum_confidence", 50))
        status_filter = self.get_config_string("tx_status_filter", None)
        if type(status_filter) == str:
            self.bridge_options["status_filter"] = status_filter.split(',')
        else:
            self.bridge_options["status_filter"] = None

        return True
    def test_single_env_var(self, monkeypatch):
        expected_token = 'app_id|app_secret'

        monkeypatch.setenv(te.TX_ACCESS_TOKEN, expected_token)
        access_token.init()
        self.verify_token(expected_token)
    def test_app_id_and_secret(self):
        expected_token = 'app_id|app_secret'

        with patch('pytx.access_token._find_token_file', return_value=None):
            access_token.init(app_id='app_id', app_secret='app_secret')
            self.verify_token(expected_token)
 def test_only_app_secret(self):
     with nested(
         pytest.raises(pytxInitError),
         patch('pytx.access_token._find_token_file', return_value=None)
     ):
         access_token.init(app_secret='app_secret')
 def test_no_token(self):
     with nested(
         pytest.raises(pytxInitError),
         patch('pytx.access_token._find_token_file', return_value=None)
     ):
         access_token.init()