def test_package_json_handles_non_unicode(self):
     package = Package(name=b'\xf6', version=b'\xf6', release=b'\xf6', arch=b'\xf6', vendor=b'\xf6')
     data = package.to_dict()
     json_str = json.dumps(data)  # to json
     data = json.loads(json_str)  # and back to an object
     for attr in ['name', 'version', 'release', 'arch', 'vendor']:
         self.assertEqual(u'\ufffd', data[attr])

    def test_facts_has_changed_cache_is_none(self, mock_load_hw, mock_load_cf, mock_read_cache):
        test_facts = json.loads(facts_buf)
        mock_load_hw.return_value = test_facts

        changed = self.f.has_changed()
        self.assert_equal_dict(test_facts, self.f.facts)
        self.assertTrue(changed)

 def test_package_json_missing_attributes(self):
     package = Package(name=None, version=None, release=None, arch=None, vendor=None)
     data = package.to_dict()
     json_str = json.dumps(data)  # to json
     data = json.loads(json_str)  # and back to an object
     for attr in ['name', 'version', 'release', 'arch', 'vendor']:
         self.assertEqual(None, data[attr])

 def check_for_update(self):
     if self.exists():
         data = json.loads(self.read())
         last_update = parse_date(data["lastUpdate"])
     else:
         last_update = None
     return self._query_for_update(if_modified_since=last_update)

    def test_facts_has_changed_cache_exists_false(self, mock_load_hw, mock_load_cf, mock_read_cache):

        test_facts = json.loads(facts_buf)
        mock_load_hw.return_value = test_facts

        changed = self.f.has_changed()
        self.assertTrue(changed)

    def test_write_cache(self):
        mock_server_status = {'fake server status': random.uniform(1, 2 ** 32)}
        status_cache = EntitlementStatusCache()
        status_cache.server_status = mock_server_status
        cache_dir = tempfile.mkdtemp()
        cache_file = os.path.join(cache_dir, 'status_cache.json')
        status_cache.CACHE_FILE = cache_file
        status_cache.write_cache()

        # try to load the file 5 times, if
        # we still can't read it, fail
        # we don't know when the write_cache thread ends or
        # when it starts. Need to track the cache threads
        # but we do not...

        tries = 0
        while tries <= 5:
            try:
                new_status_buf = open(cache_file).read()
                new_status = json.loads(new_status_buf)
                break
            except Exception as e:
                log.exception(e)
                tries += 1
                time.sleep(.1)
                continue

        shutil.rmtree(cache_dir)
        self.assertEqual(new_status, mock_server_status)

    def __init__(self, from_file=None):
        """
        Load the RPM package profile from a given file, or from rpm itself.

        NOTE: from_file is a file descriptor, not a file name.
        """
        self.packages = []
        if from_file:
            log.debug("Loading RPM profile from file.")
            json_buffer = from_file.read()
            pkg_dicts = json.loads(json_buffer)
            for pkg_dict in pkg_dicts:
                self.packages.append(Package(
                    name=pkg_dict['name'],
                    version=pkg_dict['version'],
                    release=pkg_dict['release'],
                    arch=pkg_dict['arch'],
                    epoch=pkg_dict['epoch'],
                    vendor=pkg_dict['vendor']
                ))
        else:
            log.debug("Loading current RPM profile.")
            ts = rpm.TransactionSet()
            ts.setVSFlags(-1)
            installed = ts.dbMatch()
            self.packages = self._accumulate_profile(installed)

 def setUp(self):
     SubManFixture.setUp(self)
     self.status = json.loads(INST_PROD_STATUS)['installedProducts']
     self.prod_status_cache = NonCallableMock()
     self.prod_status_cache.load_status = Mock(return_value=self.status)
     inj.provide(inj.PROD_STATUS_CACHE, self.prod_status_cache)
     self.calculator = ValidProductDateRangeCalculator(None)

 def test_package_json_as_unicode_type(self):
     # note that the data type at time of writing is bytes, so this is just defensive coding
     package = Package(name=u'Björk', version=u'Björk', release=u'Björk', arch=u'Björk', vendor=u'Björk')
     data = package.to_dict()
     json_str = json.dumps(data)  # to json
     data = json.loads(json_str)  # and back to an object
     for attr in ['name', 'version', 'release', 'arch', 'vendor']:
         self.assertEqual(u'Björk', data[attr])

 def _print_consumer(self, zip_archive):
     # Print out the consumer data
     part = zip_archive._read_file(os.path.join("export", "consumer.json"))
     data = json.loads(part)
     to_print = []
     to_print.append((_("Name"), get_value(data, "name")))
     to_print.append((_("UUID"), get_value(data, "uuid")))
     to_print.append((_("Type"), get_value(data, "type.label")))
     self._print_section(_("Consumer:"), to_print)

    def test_facts_has_changed_with_change(self, mock_collect):
        test_facts = json.loads(facts_buf)
        # change socket fact count from what is in the cache
        test_facts['cpu.cpu_socket(s)'] = '16'
        mock_collect.return_value = test_facts

        changed = self.f.has_changed()
        self.assertEqual(self.f.facts['cpu.cpu_socket(s)'], '16')
        self.assertTrue(changed)

    def test_facts_has_changed_with_change(self, mock_load_hw, mock_load_cf):
        test_facts = json.loads(facts_buf)
        # change socket fact count from what is in the cache
        test_facts["cpu.cpu_socket(s)"] = "16"
        mock_load_hw.return_value = test_facts

        changed = self.f.has_changed()
        self.assertEquals(self.f.facts["cpu.cpu_socket(s)"], "16")
        self.assertTrue(changed)

    def _parse_facts_json(self, json_buffer, file_path):
        custom_facts = None

        try:
            custom_facts = json.loads(json_buffer)
        except ValueError:
            log.warn("Unable to load custom facts file: %s" % file_path)

        return custom_facts

 def _print_general(self, zip_archive):
     # Print out general data
     part = zip_archive._read_file(os.path.join("export", "meta.json"))
     data = json.loads(part)
     to_print = []
     to_print.append((_("Server"), get_value(data, "webAppPrefix")))
     to_print.append((_("Server Version"), get_value(data, "version")))
     to_print.append((_("Date Created"), get_value(data, "created")))
     to_print.append((_("Creator"), get_value(data, "principalName")))
     self._print_section(_("General:"), to_print)

 def _load_data(self, open_file):
     try:
         self.overrides = json.loads(open_file.read()) or {}
         return self.overrides
     except IOError as err:
         log.error("Unable to read cache: %s" % self.CACHE_FILE)
         log.exception(err)
     except ValueError:
         # ignore json file parse errors, we are going to generate
         # a new as if it didn't exist
         pass

    def from_json(cls, json_blob):
        custom_facts = cls

        # Default to no facts collected
        # See BZ#1435771
        data = {}
        try:
            data = ourjson.loads(json_blob)
        except ValueError:
            log.warn("Unable to load custom facts file.")

        custom_facts.data = data
        return custom_facts

 def _decompress_payload(self, payload):
     """
     Certificate payloads arrive in zlib compressed strings
     of JSON.
     This method de-compresses and parses the JSON and returns the
     resulting dict.
     """
     try:
         decompressed = zlib.decompress(payload)
         return json.loads(decompressed)
     except Exception, e:
         log.exception(e)
         raise CertificateException("Error decompressing/parsing " "certificate payload.")

 def __read_cache_file(file_name):
     try:
         with open(file_name) as file:
             json_str = file.read()
             data = json.loads(json_str)
         return data
     except IOError as err:
         log.error("Unable to read cache: %s" % file_name)
         log.exception(err)
     except ValueError:
         # ignore json file parse errors, we are going to generate
         # a new as if it didn't exist
         pass
     return None

 def _print_consumer(self, zip_archive):
     # Print out the consumer data
     part = zip_archive._read_file(os.path.join("export", "consumer.json"))
     data = json.loads(part)
     to_print = []
     to_print.append((_("Name"), get_value(data, "name")))
     to_print.append((_("UUID"), get_value(data, "uuid")))
     # contentAccessMode is entitlement if null, blank or non-present
     contentAccessMode = 'entitlement'
     if "contentAccessMode" in data and data["contentAccessMode"] == 'org_environment':
         contentAccessMode = 'org_environment'
     to_print.append((_("Content Access Mode"), contentAccessMode))
     to_print.append((_("Type"), get_value(data, "type.label")))
     to_print.append((_("API URL"), get_value(data, "urlApi")))
     to_print.append((_("Web URL"), get_value(data, "urlWeb")))
     self._print_section(_("Consumer:"), to_print)

    def validateResponse(self, response, request_type=None, handler=None):

        # FIXME: what are we supposed to do with a 204?
        if str(response['status']) not in ["200", "204"]:
            parsed = {}
            if not response.get('content'):
                parsed = {}
            else:
                # try vaguely to see if it had a json parseable body
                try:
                    parsed = json.loads(response['content'], object_hook=self._decode_dict)
                except ValueError, e:
                    log.error("Response: %s" % response['status'])
                    log.error("JSON parsing error: %s" % e)
                except Exception, e:
                    log.error("Response: %s" % response['status'])
                    log.exception(e)