app_config 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 57a758d17f3cf8b5932064d8daaba948f2b0e51a
-  data.tar.gz: a9851dc01c313b651654a52a1b8ad8e397f82380
+  metadata.gz: 85532501e786eca705ac6224a529a1f1ea596b1f
+  data.tar.gz: cf1e1d838361c7bca2135db8274a52c2f9cef843
 SHA512:
-  metadata.gz: d7e65918fd775a55c5611d24084fe36ccc212b609fe4a864379e357b4a2f5ead09061a6c992ea40d1f80ea240e5ba75fd7a65de915665215f6009dcb2265d4b8
-  data.tar.gz: 1f7d96ba6828400f2784cbc523b4078697d8cce396b2bd8abe221f130070d69f9a5ccad961402500aa2b6012337f3be4bfe9338323dd5e00f63c1708aace227f
+  metadata.gz: 7ef79b6d4670050d2d583599d54889c2e219e71e7a8833b39f22a062a842fa919eaa06a8d74f4642548f3db3b8797cd016d66658a6ce31c0970b501ea506c9a2
+  data.tar.gz: e39497d9599c666bc615ff3ab3b669c977ce5b141cf6dff6506d54cbe50e7a3b21170a7776ace29ed5bd2439a340c10cecbdd6e3bcc2f6955dec5c6aa000fc5b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    app_config (2.0.1)
+    app_config (2.1.0)
 
 GEM
   remote: https://rubygems.org/
@@ -12,6 +12,7 @@ GEM
     mongo (1.3.1)
       bson (>= 1.3.1)
     multi_json (1.3.6)
+    pg (0.15.1)
     rake (0.9.2.2)
     redcarpet (2.3.0)
     rspec (2.10.0)
@@ -35,8 +36,9 @@ DEPENDENCIES
   app_config!
   bson_ext
   mongo
+  pg
   rake
   redcarpet
-  rspec (~> 2.10.0)
+  rspec
   simplecov
   yard

data/README.md

@@ -6,74 +6,144 @@ An easy to use, customizable library to easily store and retrieve application
 AppConfig requires at least Ruby 1.9.
 
 
-## Deprecation Note
-
-Version `2.0` is **not** backwards compatible with the `1.x` branch.
-
-See the [wiki](https://github.com/Oshuma/app_config/wiki) for upgrade instructions.
-
-
 ## Usage
 
-Usage is simple.  Just pass either a hash of options, or a block, to {AppConfig.setup!}.
+Usage is simple.  Just pass either a hash of options, or a block, to `AppConfig.setup!`.
 
 In it's simplest form, you can use it like so:
 
-    AppConfig.setup!(:admin_email => 'admin@example.com')
-    # ..or..
-    AppConfig.setup! do |config|
-      config.admin_email = 'admin@example.com'
-    end
+```ruby
+AppConfig.setup!(admin_email: 'admin@example.com')
+# ..or..
+AppConfig.setup! do |config|
+  config.admin_email = 'admin@example.com'
+end
 
-    AppConfig.admin_email  # => 'admin@example.com'
+AppConfig.admin_email  # => 'admin@example.com'
+```
 
 You may also specify the storage method along with options specific to that storage method.
 Check the [wiki](https://github.com/Oshuma/app_config/wiki) for more usage examples.
 
 
-## AppConfig::Storage::YAML
+## YAML
 
 Given this YAML file:
 
-    ---
-    admin_email: 'admin@example.com'
-    api_name:    'Supr Webz 2.0'
-    api_key:     'SUPERAWESOMESERVICE'
+```yaml
+---
+admin_email: 'admin@example.com'
+api_name:    'Supr Webz 2.0'
+api_key:     'SUPERAWESOMESERVICE'
+```
 
 Use it like so:
 
-    AppConfig.setup!(:yaml => '/path/to/app_config.yml')
+```ruby
+AppConfig.setup!(yaml: '/path/to/app_config.yml')
 
-    # Later on...
-    AppConfig.admin_email  # => 'admin@example.com'
-    AppConfig.api_name     # => 'Supr Webz 2.0'
-    AppConfig.api_key      # => 'SUPERAWESOMESERVICE'
+# Later on...
+AppConfig.admin_email  # => 'admin@example.com'
+AppConfig.api_name     # => 'Supr Webz 2.0'
+AppConfig.api_key      # => 'SUPERAWESOMESERVICE'
+```
 
 
-## AppConfig::Storage::Mongo
+## Mongo
 
-You can pass a `:mongo` options hash to {AppConfig.setup!} which should contain
-configuration values for a Mongo database.  Check the {AppConfig::Storage::Mongo::DEFAULTS}
+You can pass a `:mongo` options hash to `AppConfig.setup!` which should contain
+configuration values for a Mongo database.  Check the `AppConfig::Storage::Mongo::DEFAULTS`
 constant for the default Mongo connection options.
 
-    mongo_opts = {
-      :host       => 'localhost',   # default
-      :database   => 'app_config',  # default
-      :collection => 'app_config'   # default
-    }
+```ruby
+# These are the defaults.
+mongo_opts = {
+  host:       'localhost',
+  database:   'app_config',
+  collection: 'app_config'
+}
 
-    AppConfig.setup!(:mongo => mongo_opts)
+AppConfig.setup!(mongo: mongo_opts)
 
-    AppConfig.admin_email  # => 'admin@example.com'
+AppConfig.admin_email  # => 'admin@example.com'
 
-    # Override an existing value and save to the database:
-    AppConfig.admin_email = 'other_admin@example.com'
-    AppConfig.save!
+# Override an existing value and save to the database:
+AppConfig.admin_email = 'other_admin@example.com'
+AppConfig.save!
+```
 
 The values are read/saved (by default) to the `app_config` database and
 `app_config` collection.  These defaults can be overridden, however, which
 might lend well to versioned configurations; collection names such as
 `app_config_v1`, `app_config_v2`, etc.
 
-    AppConfig.setup!(:mongo => { :collection => 'app_config_v2' })
+```ruby
+AppConfig.setup!(mongo: { collection: 'app_config_v2' })
+```
+
+
+## PostgreSQL
+
+Using PostgreSQL is similar to a Mongo setup.
+The only current requirement is that the table have a primary key named `id`.
+All other columns are used as configuration keys.
+
+**Note:** The database and schema must exist prior to calling `AppConfig.setup!`.
+
+Given this schema:
+
+```sql
+CREATE TABLE app_config (
+  id bigserial NOT NULL PRIMARY KEY,
+  admin_email character varying(255) DEFAULT 'admin@example.com'::character varying,
+  api_key character varying(255) DEFAULT 'SOME_API_KEY'::character varying
+);
+```
+
+Setup AppConfig:
+
+```ruby
+# These are the defaults.
+postgres_opts = {
+  host:     'localhost',
+  port:     5432,
+  dbname:   'app_config',
+  table:    'app_config',
+
+  # If these are nil (or omitted), the PostgreSQL defaults will be used.
+  user:     nil,
+  password: nil,
+}
+
+AppConfig.setup!(postgres: postgres_opts)
+
+AppConfig.admin_email  # => 'admin@example.com'
+
+# Override an existing value and save to the database:
+AppConfig.admin_email = 'another_admin@example.com'
+AppConfig.save!
+```
+
+
+## Using Storage Defaults
+
+All storage options accept `true` as a value, which uses the default options for that storage.
+
+For example, to use the [Mongo](https://github.com/Oshuma/app_config/blob/master/lib/app_config/storage/mongo.rb#L9) defaults:
+
+```ruby
+AppConfig.setup!(mongo: true)
+```
+
+### Storage Defaults
+
+* [Mongo](https://github.com/Oshuma/app_config/blob/master/lib/app_config/storage/mongo.rb#L9)
+* [Postgres](https://github.com/Oshuma/app_config/blob/master/lib/app_config/storage/postgres.rb#L8)
+* [YAML](https://github.com/Oshuma/app_config/blob/master/lib/app_config/storage/yaml.rb#L9)
+
+
+## Deprecation Note
+
+Version `2.x` is **not** backwards compatible with the `1.x` branch.
 
+See the [wiki](https://github.com/Oshuma/app_config/wiki) for current usage instructions.

data/app_config.gemspec

@@ -14,9 +14,10 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bson_ext'
   s.add_development_dependency 'mongo'
+  s.add_development_dependency 'pg'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'redcarpet'
-  s.add_development_dependency 'rspec', '~> 2.10.0'
+  s.add_development_dependency 'rspec'
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
 

data/lib/app_config.rb

@@ -21,6 +21,8 @@ module AppConfig
         @@storage = AppConfig::Storage::YAML.new(@@options.delete(:yaml))
       elsif @@options[:mongo]
         @@storage = AppConfig::Storage::Mongo.new(@@options.delete(:mongo))
+      elsif @@options[:postgres]
+        @@storage = AppConfig::Storage::Postgres.new(@@options.delete(:postgres))
       else
         @@storage = AppConfig::Storage::Base.new
       end

data/lib/app_config/storage.rb

@@ -1,10 +1,8 @@
 module AppConfig
   module Storage
-    # Used when creating a new, infinitely nested Hash.
-    DEEP_HASH = lambda { |h, k| h[k] = Hash.new(&h.default_proc) }
-
-    autoload :Base,   'app_config/storage/base'
-    autoload :Mongo,  'app_config/storage/mongo'
-    autoload :YAML,   'app_config/storage/yaml'
+    autoload :Base,     'app_config/storage/base'
+    autoload :Mongo,    'app_config/storage/mongo'
+    autoload :Postgres, 'app_config/storage/postgres'
+    autoload :YAML,     'app_config/storage/yaml'
   end
 end

data/lib/app_config/storage/mongo.rb

@@ -7,18 +7,23 @@ module AppConfig
     class Mongo < Storage::Base
 
       DEFAULTS = {
-        :host       => 'localhost',
-        :port       => '27017',
-        :database   => 'app_config',
-        :collection => 'app_config',
-        :user       => nil,
-        :password   => nil
+        host:       'localhost',
+        port:       27017,
+        database:   'app_config',
+        collection: 'app_config',
+        username:   nil,
+        password:   nil,
       }
 
       def initialize(options)
-        @connected = false
-        @options = DEFAULTS.merge(options)
-        setup_connection
+        # Allows passing `true` as an option.
+        if options.is_a?(Hash)
+          @options = DEFAULTS.merge(options)
+        else
+          @options = DEFAULTS
+        end
+
+        setup_connection!
         fetch_data!
       end
 
@@ -35,13 +40,13 @@ module AppConfig
 
       private
 
-      def setup_connection
+      def setup_connection!
         @connection = ::Mongo::Connection.new(@options[:host], @options[:port].to_i)
-        authenticate_connection if @options[:user] && @options[:password]
+        authenticate_connection! if @options[:username] && @options[:password]
       end
 
-      def authenticate_connection
-        database.authenticate(@options[:user], @options[:password])
+      def authenticate_connection!
+        database.authenticate(@options[:username], @options[:password])
       end
 
       def connected?

data/lib/app_config/storage/postgres.rb

@@ -0,0 +1,76 @@
+module AppConfig
+  module Storage
+
+    require 'pg'
+
+    class Postgres < Storage::Base
+
+      DEFAULTS = {
+        host:     'localhost',
+        port:     5432,
+        dbname:   'app_config',
+        table:    'app_config',
+        user:     nil,
+        password: nil,
+      }
+
+      def initialize(options)
+        # Allows passing `true` as an option.
+        if options.is_a?(Hash)
+          @options = DEFAULTS.merge(options)
+        else
+          @options = DEFAULTS
+        end
+
+        # HACK: Remove the `user` and `password` keys if they're nil, since `@options` is passed directly to `PG.connect`.
+        @options.delete(:user) if @options[:user].nil?
+        @options.delete(:password) if @options[:password].nil?
+
+        @table = @options.delete(:table)
+
+        setup_connection!
+        fetch_data!
+      end
+
+      # Saves the data back to Postgres.  Returns `true`/`false`.
+      def save!
+        # Build the `SET foo = 'bar', ...` string for the UPDATE query.
+        data_hash = @data.to_h
+        data_hash.delete(:id)  # Remove the primary key (id) from the SET attributes.
+        set_attrs = data_hash.map { |k, v| "#{k} = '#{v}'" }.join(', ')
+
+        update_query = "UPDATE #{@table} SET #{set_attrs} WHERE id = #{@id}"
+
+        result = @connection.exec(update_query)
+        result.result_status == PG::Constants::PGRES_COMMAND_OK
+      end
+
+      private
+
+      def fetch_data!
+        raise 'Not connected to PostgreSQL' unless connected?
+
+        # TODO: This might not be the best solution here.
+        #       It currently uses the newest row, based on a primary key of `id`.
+        #       Maybe provide a way to configure what row gets returned.
+        fetch_query = "SELECT * FROM #{@table} ORDER BY id DESC LIMIT 1"
+
+        @connection.exec(fetch_query) do |result|
+          result.each do |row|
+            @data = OpenStruct.new(row)
+            @id = @data.id
+          end
+        end
+      end
+
+      def connected?
+        @connection && @connection.status == PG::Constants::CONNECTION_OK
+      end
+
+      def setup_connection!
+        @connection = PG.connect(@options)
+      end
+
+    end
+  end
+end

data/lib/app_config/storage/yaml.rb

@@ -13,6 +13,9 @@ module AppConfig
       #
       # Defaults to `Dir.home/.app_config.yml`
       def initialize(path = DEFAULT_PATH)
+        # Allows passing `true` as an option.
+        path = DEFAULT_PATH if path == true
+
         # Make sure to use the top-level YAML module here.
         @data = OpenStruct.new(::YAML.load_file(path))
       end

data/lib/app_config/version.rb

@@ -1,3 +1,3 @@
 module AppConfig
-  VERSION = '2.0.1'
+  VERSION = '2.1.0'
 end

data/spec/app_config/storage/mongo_spec.rb

@@ -16,12 +16,20 @@ describe AppConfig::Storage::Mongo do
     AppConfig.api_key = 'SOME_NEW_API_KEY'
     AppConfig.api_key.should == 'SOME_NEW_API_KEY'
 
-    AppConfig.class_variable_get(:@@storage).should_receive(:save!)
-    AppConfig.save!
+    AppConfig.save!.should be_true
   end
 
   it 'should have a @_id variable for the Mongo ID' do
-    AppConfig.class_variable_get(:@@storage).
-      instance_variable_get(:@_id).should_not be_nil
+    AppConfig.class_variable_get(:@@storage)
+      .instance_variable_get(:@_id).should_not be_nil
+  end
+
+  it "uses the defaults when 'true' is passed" do
+    AppConfig.reset!
+    AppConfig.setup!(mongo: true)
+
+    AppConfig.class_variable_get(:@@storage)
+      .instance_variable_get(:@options)
+      .should == AppConfig::Storage::Mongo::DEFAULTS
   end
 end

data/spec/app_config/storage/postgres_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe AppConfig::Storage::Postgres do
+
+  before(:all) do
+    config_for_postgres
+  end
+
+  it 'should have some values' do
+    AppConfig.api_key.should_not be_nil
+  end
+
+  it 'should update the values' do
+    new_api_key = 'SOME_NEW_API_KEY'
+    AppConfig.api_key = new_api_key
+
+    AppConfig.save!.should be_true
+
+    # Reload AppConfig
+    config_for_postgres
+
+    AppConfig.api_key.should == new_api_key
+  end
+
+  it "uses the defaults when 'true' is passed" do
+    AppConfig.reset!
+
+    # Hack to use a test database as the 'default'.
+    AppConfig::Storage::Postgres::DEFAULTS[:dbname] = 'app_config_test'
+
+    begin
+      AppConfig.setup!(postgres: true)
+    rescue PG::Error => e
+      config_for_postgres
+    end
+
+    AppConfig.class_variable_get(:@@storage)
+    .instance_variable_get(:@options)
+    .should == AppConfig::Storage::Postgres::DEFAULTS
+  end
+end

data/spec/app_config/storage/yaml_spec.rb

@@ -9,7 +9,7 @@ describe AppConfig::Storage::YAML do
 
   it 'should raise file not found' do
     lambda do
-      config_for_yaml(:yaml => 'not/a/real/file.yml')
+      config_for_yaml(yaml: 'not/a/real/file.yml')
     end.should raise_error(Errno::ENOENT)
   end
 
@@ -25,4 +25,13 @@ describe AppConfig::Storage::YAML do
     end
   end
 
+  it "uses the defaults when 'true' is passed" do
+    AppConfig.reset!
+
+    # Hack to use spec config as the 'default'
+    AppConfig::Storage::YAML::DEFAULT_PATH = fixture('app_config.yml')
+
+    AppConfig.setup!(yaml: true)
+    AppConfig.api_key.should_not be_nil
+  end
 end

data/spec/app_config_spec.rb

@@ -25,7 +25,7 @@ describe AppConfig do
 
   it 'should reset @@storage' do
     # configure first
-    config_for_yaml(:api_key => 'API_KEY')
+    config_for_yaml
     # then reset
     AppConfig.reset!
     AppConfig.send(:storage).should be_nil
@@ -46,15 +46,6 @@ describe AppConfig do
     AppConfig.should be_setup
   end
 
-  it 'should create nested keys' do
-    pending 'Re-implement this later.'
-    AppConfig.reset!
-    AppConfig.setup!
-
-    AppConfig.person.name.first = 'Dale'
-    AppConfig.person.name.first.should == 'Dale'
-  end
-
   it 'returns a Hash on setup' do
     AppConfig.reset!
     config = AppConfig.setup! do |c|

data/spec/spec_helper.rb

@@ -23,29 +23,46 @@ RSpec.configure do |config|
   # Setup YAML options and pass to config_for().
   def config_for_yaml(opts = {})
     path = opts[:yaml] || fixture('app_config.yml')
-    config_for({ :yaml => path }.merge(opts))
+    config_for({ yaml: path }.merge(opts))
   end
 
   def config_for_mongo(opts = {}, load_test_data = true)
     mongo = AppConfig::Storage::Mongo::DEFAULTS.merge({
-      :host => 'localhost',
-      :database => 'app_config_test',
+      database: 'app_config_test',
     })
     begin
       load_mongo_test_config(mongo) if load_test_data
-      config_for({:mongo => mongo}.merge(opts))
+      config_for({mongo: mongo}.merge(opts))
     rescue Mongo::ConnectionFailure
       pending "***** Mongo specs require a running MongoDB server *****"
     end
   end
 
+  def config_for_postgres(opts = {}, load_test_data = true)
+    postgres = AppConfig::Storage::Postgres::DEFAULTS.merge({
+      dbname: 'app_config_test'
+    })
+
+    begin
+      load_postgres_test_config(postgres) if load_test_data
+      config_for({postgres: postgres}.merge(opts))
+    rescue PG::Error => e
+      if e.to_s =~ /could not connect to server/
+        pending "***** Postgres specs require a running PostgreSQL server *****"
+      else
+        # Re-raise the exception, since we only care about connectivity here.
+        raise e
+      end
+    end
+  end
+
   private
 
   def load_mongo_test_config(options)
     connection = ::Mongo::Connection.new(options[:host], options[:port].to_i)
     database   = connection.db(options[:database])
     collection = database.collection(options[:collection])
-    test_data = YAML.load_file(fixture('app_config_mongo.yml'))
+    test_data = YAML.load_file(fixture('app_config.yml'))
 
     data = collection.find_one
     if data
@@ -54,4 +71,37 @@ RSpec.configure do |config|
       collection.save(test_data)
     end
   end
+
+  def load_postgres_test_config(options)
+    original_options = options.dup
+
+    options.delete(:user) if options[:user].nil?
+    options.delete(:password) if options[:password].nil?
+
+    table = options.delete(:table)
+
+    begin
+      connection = ::PG.connect(options)
+
+      config = ::YAML.load_file(fixture('app_config.yml'))
+      attrs = config.keys.map { |k| "#{k} character varying(255)" }.join(', ')
+
+      create_query = "CREATE TABLE #{table} (id bigserial primary key, #{attrs})"
+      insert_query = "INSERT INTO #{table} (#{config.keys.join(', ')}) VALUES (#{config.values.map { |v| "'#{v}'" }.join(', ')})"
+
+      connection.exec(create_query)
+      connection.exec(insert_query)
+    rescue PG::Error => e
+      case e.to_s
+      when /database "#{options[:dbname]}" does not exist/
+        %x[createdb -U `whoami` -O `whoami` #{options[:dbname]}]
+        load_postgres_test_config(original_options)
+      when /relation "#{table}" already exists/
+        # no-op
+      else
+        raise e
+      end
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: app_config
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Dale Campbell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-02 00:00:00.000000000 Z
+date: 2013-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bson_ext
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +84,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
-        version: 2.10.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -130,15 +144,15 @@ files:
 - lib/app_config/storage.rb
 - lib/app_config/storage/base.rb
 - lib/app_config/storage/mongo.rb
+- lib/app_config/storage/postgres.rb
 - lib/app_config/storage/yaml.rb
 - lib/app_config/version.rb
 - spec/app_config/storage/mongo_spec.rb
+- spec/app_config/storage/postgres_spec.rb
 - spec/app_config/storage/yaml_spec.rb
 - spec/app_config/storage_spec.rb
 - spec/app_config_spec.rb
 - spec/fixtures/app_config.yml
-- spec/fixtures/app_config_mongo.yml
-- spec/fixtures/env_app_config.yml
 - spec/spec_helper.rb
 homepage: http://oshuma.github.io/app_config
 licenses: []
@@ -167,11 +181,10 @@ specification_version: 4
 summary: Quick and easy application configuration.
 test_files:
 - spec/app_config/storage/mongo_spec.rb
+- spec/app_config/storage/postgres_spec.rb
 - spec/app_config/storage/yaml_spec.rb
 - spec/app_config/storage_spec.rb
 - spec/app_config_spec.rb
 - spec/fixtures/app_config.yml
-- spec/fixtures/app_config_mongo.yml
-- spec/fixtures/env_app_config.yml
 - spec/spec_helper.rb
 has_rdoc: true

data/spec/fixtures/app_config_mongo.yml

@@ -1,5 +0,0 @@
-# Test values loaded into the Mongo db.
----
-admin_email: 'admin@example.com'
-api_name:    'Supr Webz 2.0'
-api_key:     'SUPERAWESOMESERVICE'

data/spec/fixtures/env_app_config.yml

@@ -1,17 +0,0 @@
-defaults: &defaults
-  title: 'AppConfig Env Mode'
-  admin_email: 'admin@example.com'
-  api_name:    'Supr Webz 2.0'
-  api_key:     'SUPERAWESOMESERVICE'
-
-development:
-  <<: *defaults
-  admin_email: 'dev@example.com'
-
-production:
-  <<: *defaults
-  title: 'AppConfig Env Production Mode!'
-
-test:
-  <<: *defaults
-  admin_email: 'test@example.com'