     if Repo.all(Setting) == [],
       do: Factory.insert_list(3, :setting)
     :ok
-  end
-
-  defp format_settings(settings, mapper \\ nil) do
-    Enum.into(settings, %{}, fn setting ->
-      setting_tuple =
-        case setting do
-          setting = %Setting{} ->
-            {setting.setting_id, setting.default_value}
-          setting = %AccountSetting{} ->
-            {setting.setting_id, setting.setting_value}
-          {setting_id, setting_value} ->
-            {setting_id, setting_value}
-        end
-
-      if mapper,
-        do: mapper.(setting_tuple),
-        else: setting_tuple
-    end)
   end
 
   describe "changing specific settings" do


  use ExUnit.Case, async: true

  alias Helix.Account.Controller.AccountSetting, as: AccountSettingController
  alias Helix.Account.Model.AccountSetting
  alias Helix.Account.Model.Setting
  alias Helix.Account.Repo


  end

  describe "fetching every setting" do
    test "includes default and modified settings" do
      account = Factory.insert(:account)
      settings = Repo.all(Setting)
      value = Random.string()

      settings
      |> Enum.take_random(3)
      |> Enum.each(&AccountSettingController.put(account, &1.setting_id, value))

      account_settings = AccountSettingController.get_settings(account)
      defaults = Enum.into(settings, %{}, &{&1.setting_id, &1.default_value})
      diff = Map.values(account_settings) -- Map.values(defaults)

      assert Map.keys(account_settings) == Map.keys(defaults)
      assert 3 == Enum.count(diff)
    end

    test "includes every unchanged setting" do
      account = Factory.insert(:account)

      account_settings = AccountSettingController.get_settings(account)
      default_settings =
        Setting
        |> Repo.all()
        |> Enum.into(%{}, &{&1.setting_id, &1.default_value})

      assert account_settings == default_settings
    end
