def test_serializer_outputs_expected_schema_for_multipref(self):
experiment = ExperimentFactory.create(
name="public name",
firefox_min_version="70.0",
locales=[LocaleFactory.create()],
countries=[CountryFactory.create()],
public_description="this is my public description!",
recipe_slug="some-random-slug",
platforms=[
Experiment.PLATFORM_WINDOWS,
Experiment.PLATFORM_MAC,
Experiment.PLATFORM_LINUX,
],
is_multi_pref=True,
)
variant = ExperimentVariant(
slug="slug-value", ratio=25, experiment=experiment, is_control=True
)
variant.save()
pref = VariantPreferencesFactory.create(variant=variant)
expected_comment = expected_comment = f"{experiment.client_matching}\n"
serializer = ExperimentRecipeSerializer(experiment)
self.assertEqual(serializer.data["action_name"], "multi-preference-experiment")
self.assertEqual(serializer.data["name"], experiment.name)
self.assertEqual(serializer.data["comment"], expected_comment)
self.assertEqual(
serializer.data["filter_object"],
[
FilterObjectBucketSampleSerializer(experiment).data,
FilterObjectChannelSerializer(experiment).data,
FilterObjectVersionsSerializer(experiment).data,
FilterObjectLocaleSerializer(experiment).data,
FilterObjectCountrySerializer(experiment).data,
],
)
expected_data = {
"slug": "some-random-slug",
"experimentDocumentUrl": experiment.experiment_url,
"userFacingName": "public name",
"userFacingDescription": "this is my public description!",
"branches": [
{
"preferences": {
pref.pref_name: {
"preferenceBranchType": pref.pref_branch,
"preferenceType": pref.pref_type,
"preferenceValue": pref.pref_value,
}
},
"ratio": 25,
"slug": "slug-value",
}
],
}
self.assertDictEqual(serializer.data["arguments"], expected_data)
def test_serializer_outputs_expected_schema_for_message(self):
experiment = ExperimentFactory.create(
type=Experiment.TYPE_MESSAGE,
firefox_min_version="70.0",
locales=[LocaleFactory.create()],
countries=[CountryFactory.create()],
public_description="this is my public description!",
public_name="public name",
normandy_slug="some-random-slug",
platforms=[Experiment.PLATFORM_WINDOWS],
)
variant = ExperimentVariant(slug="slug-value",
ratio=25,
experiment=experiment,
is_control=True)
variant.save()
expected_comment = expected_comment = (
f"{experiment.client_matching}\n"
f"Platform: ['All Windows']\n")
serializer = ExperimentRecipeSerializer(experiment)
self.assertEqual(serializer.data["action_name"],
"messaging-experiment")
self.assertEqual(serializer.data["name"], experiment.name)
self.assertEqual(serializer.data["comment"], expected_comment)
self.assertEqual(
serializer.data["filter_object"],
[
FilterObjectBucketSampleSerializer(experiment).data,
FilterObjectChannelSerializer(experiment).data,
FilterObjectVersionsSerializer(experiment).data,
FilterObjectLocaleSerializer(experiment).data,
FilterObjectCountrySerializer(experiment).data,
],
)
expected_data = {
"slug":
"some-random-slug",
"experimentDocumentUrl":
experiment.experiment_url,
"userFacingName":
"public name",
"userFacingDescription":
"this is my public description!",
"branches": [{
"groups": [],
"value": {},
"ratio": 25,
"slug": "slug-value"
}],
}
self.assertEqual(serializer.data["arguments"], expected_data)
def test_serializer_outputs_expected_multipref_schema_for_singularpref(self):
experiment = ExperimentFactory.create(
name="public name",
pref_type=Experiment.PREF_TYPE_INT,
pref_branch=Experiment.PREF_BRANCH_DEFAULT,
firefox_min_version="70.0",
locales=[LocaleFactory.create()],
countries=[CountryFactory.create()],
public_description="this is my public description!",
recipe_slug="some-random-slug",
platforms=[Experiment.PLATFORM_WINDOWS],
)
variant = ExperimentVariant(
slug="slug-value", ratio=25, experiment=experiment, value=5
)
variant.save()
expected_comment = expected_comment = (
f"{experiment.client_matching}\n" f"Platform: ['All Windows']\n"
)
serializer = ExperimentRecipeSerializer(experiment)
self.assertEqual(serializer.data["action_name"], "multi-preference-experiment")
self.assertEqual(serializer.data["name"], experiment.name)
self.assertEqual(serializer.data["comment"], expected_comment)
self.assertEqual(
serializer.data["filter_object"],
[
FilterObjectBucketSampleSerializer(experiment).data,
FilterObjectChannelSerializer(experiment).data,
FilterObjectVersionsSerializer(experiment).data,
FilterObjectLocaleSerializer(experiment).data,
FilterObjectCountrySerializer(experiment).data,
],
)
expected_data = {
"slug": "some-random-slug",
"experimentDocumentUrl": experiment.experiment_url,
"userFacingName": "public name",
"userFacingDescription": "this is my public description!",
"branches": [
{
"preferences": {
experiment.pref_name: {
"preferenceBranchType": "default",
"preferenceType": Experiment.PREF_TYPE_INT,
"preferenceValue": 5,
}
},
"ratio": 25,
"slug": "slug-value",
}
],
}
self.assertDictEqual(serializer.data["arguments"], expected_data)
def test_serializer_outputs_expect_schema_for_branched_addon(self):
experiment = ExperimentFactory.create(
firefox_min_version="70.0",
type=Experiment.TYPE_ADDON,
locales=[LocaleFactory.create()],
countries=[CountryFactory.create()],
public_description="this is my public description!",
public_name="public name",
normandy_slug="some-random-slug",
platforms=[Experiment.PLATFORM_LINUX],
)
variant = ExperimentVariant(slug="slug-value",
ratio=25,
experiment=experiment)
variant.save()
serializer = ExperimentRecipeSerializer(experiment)
self.assertEqual(serializer.data["action_name"],
"branched-addon-study")
self.assertEqual(serializer.data["name"], experiment.name)
expected_comment = f"{experiment.client_matching}\n" f"Platform: ['All Linux']\n"
self.assertEqual(serializer.data["comment"], expected_comment)
self.assertEqual(
serializer.data["filter_object"],
[
FilterObjectBucketSampleSerializer(experiment).data,
FilterObjectChannelSerializer(experiment).data,
FilterObjectVersionsSerializer(experiment).data,
FilterObjectLocaleSerializer(experiment).data,
FilterObjectCountrySerializer(experiment).data,
],
)
self.assertEqual(
serializer.data["arguments"],
{
"slug":
"some-random-slug",
"userFacingName":
"public name",
"userFacingDescription":
"this is my public description!",
"branches": [{
"ratio": 25,
"slug": "slug-value",
"extensionApiId": None
}],
},
)
def update(self, instance, validated_data):
try:
with transaction.atomic():
variants_data = validated_data.pop("variants", [])
instance = super().update(instance, validated_data)
if variants_data:
existing_variant_ids = set(instance.variants.all().values_list(
"id", flat=True))
# Create or update variants
for variant_data in variants_data:
variant_data["experiment"] = instance
variant_data["slug"] = slugify(variant_data["name"])
ExperimentVariant(**variant_data).save()
# Delete removed variants
submitted_variant_ids = set(
[v.get("id") for v in variants_data if v.get("id")])
removed_ids = existing_variant_ids - submitted_variant_ids
if removed_ids:
ExperimentVariant.objects.filter(
id__in=removed_ids).delete()
self.update_changelog(instance, validated_data)
return instance
except IntegrityError:
error_string = (
"Error: unable to save this change, please contact an experimenter admin"
)
error = [{"name": error_string}] * len(variants_data)
raise serializers.ValidationError({"variants": error})
def test_serializer_outputs_expected_schema_non_multi_pref_format(self):
experiment = ExperimentFactory.create(
normandy_slug="normandy-slug",
pref_branch=Experiment.PREF_BRANCH_DEFAULT,
pref_type=Experiment.PREF_TYPE_JSON_STR,
pref_key="browser.pref",
firefox_min_version="55.0",
)
variant = ExperimentVariant(slug="control",
ratio=25,
experiment=experiment,
value='{"some": "json"}')
serializer = ExperimentRecipeMultiPrefVariantSerializer(variant)
expected_data = {
"preferences": {
"browser.pref": {
"preferenceBranchType": "default",
"preferenceType": "string",
"preferenceValue": '{"some": "json"}',
}
},
"ratio": 25,
"slug": "control",
}
self.assertEqual(expected_data, serializer.data)
def test_serializer_outputs_expected_schema(self):
variant = ExperimentVariant(slug="slug-value", ratio=25)
serializer = ExperimentRecipeAddonVariantSerializer(variant)
self.assertDictEqual(
{
"ratio": 25,
"slug": "slug-value",
"extensionApiId": None
}, serializer.data)
def update(self, instance, validated_data):
variants_data = validated_data.pop("variants")
instance = super().update(instance, validated_data)
existing_variant_ids = set(instance.variants.all().values_list(
"id", flat=True))
# Create or update variants
for variant_data in variants_data:
variant_data["experiment"] = instance
variant_data["slug"] = slugify(variant_data["name"])
ExperimentVariant(**variant_data).save()
# Delete removed variants
submitted_variant_ids = set(
[v.get("id") for v in variants_data if v.get("id")])
removed_ids = existing_variant_ids - submitted_variant_ids
if removed_ids:
ExperimentVariant.objects.filter(id__in=removed_ids).delete()
return instance
def test_variant_json_load(self):
variant = ExperimentVariant()
variant.value = '{"key": "value"}'
self.assertEqual(variant.json_load_value, {"key": "value"})
def test_variant_json_dumps(self):
variant = ExperimentVariant()
variant.value = '{"key": "value","key1":"value1"}'
expected_value = json.dumps({"key": "value", "key1": "value1"}, indent=2)
self.assertEqual(variant.json_dumps_value, expected_value)