leap_salesforce 0.1.0

data/lib/leap_salesforce/soql_data/data_relationships.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Represents common relationships from a Data class
+module DataRelationships
+  # @example
+  #   # Retrieve organisation record associated to an opportunity and then get its name
+  #   Opportunity.organisation.name
+  # Retrieve organisation related to current opportunity
+  def organisation
+    raise '"Organisation" class not yet defined' unless defined? Organisation
+
+    Organisation.get(Id: self['AccountId'])
+  end
+
+  # @example Get user name
+  #   record.owner.name
+  # @return [Exchange] object representing owner of object
+  def owner
+    User.get(Id: self[:owner_id])
+  end
+
+  # @example Get user name
+  #   record.queue.name
+  # @return [Exchange] object representing owner of object
+  def queue
+    Group.get(Id: self[:owner_id])
+  end
+
+  # Retrieve record type for current object
+  def record_type
+    raise '"RecordType" class not yet defined' unless defined? RecordType
+
+    RecordType.get(Id: self['RecordTypeId'])
+  end
+end

data/lib/leap_salesforce/soql_data/meta_data_handler.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Handles tests interaction and verification based upon Metadata
+class MetaDataHandler
+  @objects_to_verify = []
+  class << self
+    # @return [Array] List of objects to verify metadata for. This includes enums, required values
+    #   Changes to these values will need to be version controlled
+    attr_accessor :objects_to_verify
+  end
+end

data/lib/leap_salesforce/soql_data/soql_data.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require_relative 'meta_data_handler'
+require_relative 'soql_handler'
+require_relative 'soql_global_data'
+require_relative 'data_relationships'
+require_relative 'soql_global_object_data'
+require_relative 'soql_object_describe'
+require_relative 'soql_enum'
+require_relative 'soql_settings'
+
+# Represents an API interaction via SOQL queries with the Salesforce database
+class SoqlData < Exchange
+  include DataRelationships
+  extend SoqlGlobalData
+  extend SoqlGlobalObjectData
+  extend SoqlObjectDescribe
+  extend SoqlSettings
+
+  # Create a new SoqlData object. If override_parameters are empty then it's assumed creation of
+  # an object is being done
+  #
+  # @example Create a new Contact step by step (Contact inherits from this class)
+  #   contact = Contact.new
+  #   contact.first_name = 'Bob'
+  #   contact.last_name = 'Smith'
+  #   contact.save! # API request made at this point
+  #
+  # @example Create a contact using a factory with a trait of :email
+  #   contact_with_email = FactoryBot.create(:contact, :email)
+  #
+  # @example Perform a get to the Salesforce limits api
+  #   SoqlData.new("Limits", method: :get, suburl: 'limits/')
+  #
+  # @param [String] name Name describing object. Defaults to itself
+  # @param [Hash] http_parameters Parameters used in making HTTP request. If creating a new object
+  #   leave this to empty. Otherwise Hash would look like method: :get, suburl: 'URL_AFTER_SOQL_HANDLER_BASE_URL'
+  def initialize(name = nil, http_parameters = {})
+    super
+
+    return unless http_parameters.empty?
+
+    table_name = self.class.soql_object_name
+    self.suburl = "sobjects/#{table_name}"
+    optional_name = self.class.to_s == table_name ? '' : "(#{table_name})"
+    self.test_name = "Factory for '#{self.class}'#{optional_name}" unless name
+  end
+
+  # @return [String] User used to make api calls
+  attr_accessor :api_user
+
+  expect_positive_status # Retry upon failure for successful status code
+
+  # Api username below references stored variable through ERB so this can be changed at run time (otherwise user would be fixed)
+  default_handler SoqlHandler, 'Factory', api_user: '<%= LeapSalesforce.api_user %>'
+  @ids_to_delete = {}
+  @api_user = LeapSalesforce.api_user
+
+  # Unsets the element so it's not set in the request at all (not just not setting it to empty)
+  # @param [String, Symbol] element_to_unset Element to remove from being sent
+  def unset=(element_to_unset)
+    @override_parameters[:body].delete element_to_unset.to_sym
+  end
+
+  # Extract the id or return the cached version of it
+  # @return [String] Id of Salesforce Object
+  def id
+    @id ||= self['$..id,$..Id']
+  end
+
+  # @param [Boolean] set Whether to not retry for successful response (Used when you expect an error)
+  def no_retry=(set)
+    return unless set
+
+    # Set retry_count to 0 so if an invalid status code is returned a retry will not occur
+    define_singleton_method('retry_count') { 0 }
+  end
+
+  # Get details of itself by searching for it's id
+  # Store response within itself
+  # @return [Exchange] Exchange with details of data
+  def get
+    @response = self.class.get(Id: id).response # Make get call and store result
+    self
+  end
+
+  # Update current record with data provided
+  # @param [Hash] data Data to update exchange with
+  def update(data)
+    self.class.update(id, data)
+  end
+
+  # Delete current record
+  # @param [Boolean] must_pass Whether to raise exception if call is not successful
+  # @return [Exchange] Exchange object making delete
+  def delete(must_pass: false)
+    self.class.delete(id, must_pass: must_pass)
+  end
+
+  # Delete current record, switching to Admin before doing so
+  # @param [Boolean] must_pass Whether to raise exception if call is not successful
+  # @return [Exchange] Exchange object making delete
+  def delete_as_admin(must_pass: true)
+    LeapSalesforce.api_username = Test.email_for('System Admin')
+    delete must_pass: must_pass
+  end
+
+  # Update current record with data provided expecting success
+  # @param [Hash] data Data to update exchange with
+  def success_update(data)
+    update(**data, must_pass: true)
+  end
+
+  # @return [Array] List of ids from response
+  def ids
+    values_from_path('$..Id')
+  end
+
+  # Set a parameter request in the request body.
+  # Can be used to build a request over several steps (e.g Cucumber)
+  # Will be used with FactoryBot
+  #
+  # @example
+  #   exchange['name'] = 'tester'
+  #   # Will set { name: tester } in the response, formatting as JSON or XML depending on REST / SOAP
+  # @param [String, Symbol] key Name of request element to set
+  # @param [String] value Value to set request element to
+  def []=(key, value)
+    @override_parameters[:body] ||= {}
+    value = value.salesforce_format if value.is_a? Time
+    @override_parameters[:body][key] = value
+  end
+
+  # @return [String] Error message if present
+  def diagnose_error
+    return error_message if error_message?
+
+    return response if @response # If response is made it would be helpful in diagnosing
+
+    inspect # If no response, this may help
+  end
+
+  # @return [Boolean] Whether error message element is present
+  def error_message?
+    error_message_element?
+  end
+
+  # @return [String] Error message if present. If not an error is raised
+  def error_message
+    if error_message?
+      self[:message]
+    else
+      message = "No error message received. Status code is #{status_code}. "
+      message += 'Response is successful when it should not be. ' if status_code.to_s[0] == '2'
+      message += 'Response is empty' if response.to_s.empty?
+      raise LeapSalesforce::ResponseError, message
+
+    end
+  end
+
+  # @return [True, LeapSalesforce::ResponseError] Whether response is successful
+  def successful?
+    raise LeapSalesforce::ResponseError, "Error with updating #{self} #{diagnose_error}" unless (200..299).cover? status_code
+
+    true
+  end
+
+  # Returns descendants of the provided class SoqlData
+  # @return [Class] Classes that inherit from this class
+  def self.descendants
+    ObjectSpace.each_object(Class).select { |class_name| class_name < self }
+  end
+end

data/lib/leap_salesforce/soql_data/soql_enum.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Module all SoqlEnums include
+module SoqlEnum
+  def self.values_for(object)
+    ObjectSpace.each_object(Module).select { |class_name| class_name < self && class_name.to_s.start_with?("#{object}::") }
+  end
+end

data/lib/leap_salesforce/soql_data/soql_global_data.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Global Methods to interact with Soql Data
+module SoqlGlobalData
+  attr_accessor :ids_to_delete
+
+  # Return limits of Salesforce org. https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_limits.htm
+  # @example See Conga limits
+  #   SoqlData.limits["['Conga Composer - EU']"]
+  # @return [Exchange] Limits of Salesforce ORG
+  def limits
+    @limits ||= new("#{self} limits", method: :get, suburl: 'limits/')
+  end
+
+  # Describe all salesforce objects (this returns BIG response)
+  # See https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_describeGlobal.htm for reference
+  # @example Count how many sobjects there are
+  #   objects = SoqlData.global_describe['sobjects']
+  #   objects.size
+  # @example Find description of object with label Organisation
+  #   org_desc = SoqlData.global_describe['sobjects'].find { |obj| obj['label'] == 'Organisation' }
+  # @return [Exchange] Global describe of salesforce Objects
+  def global_describe
+    @global_describe ||= new('Global describe of sobjects', method: :get, suburl: 'sobjects/')
+  end
+end

data/lib/leap_salesforce/soql_data/soql_global_object_data.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+# Methods for working with instances of global to soql objects, not global overall
+# See https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_sobject_describe.htm
+module SoqlGlobalObjectData
+  # @return [Hash] List of ids to delete when deleting a particular object
+  attr_accessor :ids_to_delete
+
+  # Override to handle removing dependent records
+  def remove_dependent_records(_id); end
+
+  # Return key and value to look up for a provided hash
+  # @return [Array] Array with [column_to_lookup, value_to_look_for]
+  def extract_lookup(lookup)
+    raise 'Need to pass to Soql object key value pair to look up by' unless lookup.first.is_a? Array
+
+    lookup_key, lookup_value = lookup.first
+    raise 'Need to set lookup_key' unless lookup_key
+
+    [lookup_key, lookup_value]
+  end
+
+  # Url enconding needs to be used when searching for special characters (+ => '%2B')
+  # (see https://www.w3schools.com/tags/ref_urlencode.asp)
+  # @param [String] soql_query String representing SOQL query
+  # @param [Boolean] wait Whether to wait for record if no result returned
+  # @example
+  #   query SELECT Name from Account WHERE Name = 'TEST Org 001'
+  #   This is converted to:
+  #   perform_query "SELECT+Name+from+Account+WHERE+Name+=+'TEST+Org+001'"
+  # @return [Exchange] Exchange object from which JSON response can be obtained (i.e, with exchange.response)
+  def query(soql_query, wait: true)
+    rest_query = soql_query.gsub('%', '%25').gsub('+', '%2B').tr(' ', '+')
+    if wait
+      new("SOQL Query: #{soql_query}", method: :get, suburl: "query/?q=#{rest_query}").until(timeout: 20, interval: 1) do
+        response.body.include? '"url"' # Could be waiting for element to be created
+      end
+    else
+      new("SOQL Query: #{soql_query}", method: :get, suburl: "query/?q=#{rest_query}")
+    end
+  end
+
+  # @param [Symbol, String] lookup Hash representing look up performed
+  # @param [String] url Url to get
+  def data_from_url(url, lookup)
+    new("Id at #{url}", method: :get, suburl: url.split("v#{SoqlHandler.api_version}/").last)
+  rescue NoElementAtPath
+    raise NoElementAtPath, "No result found for #{lookup} under user #{LeapSalesforce.api_user}"
+  end
+
+  # For dates (ending with .000Z), query is always greater than
+  # @param [Hash] lookup Hash to look up values according to
+  # @return [String] SOQL query to filter results
+  def soql_lookup_filter(lookup)
+    limit = lookup.delete(:limit)
+    conditional = ''
+    lookup.each do |key, value|
+      conditional_term = conditional.empty? ? 'WHERE' : 'AND'
+      conditional += "#{conditional_term} #{key} #{condition_for(value)} "
+    end
+    query = conditional + 'ORDER BY CreatedDate DESC NULLS FIRST'
+    query += " LIMIT #{limit}" if limit
+    query
+  end
+
+  # Get the response data for a SoqlObject using the calling class's table.
+  # Will get the latest created date.
+  # @example
+  #   # Get a contact where LastName is 'Bob'
+  #   Contact.get(LastName: 'Bob')
+  # @param [Hash] lookup Key value pair unique to Salesforce to query for
+  # @option lookup [Boolean] :teardown Whether to remove id after scenario finished
+  # @return [SoqlData]
+  def get(lookup)
+    teardown = lookup.delete(:teardown)
+    SoqlHandler.new("Query on #{self}").use
+    instance_to_get = if lookup.key? :Id
+                        new("Lookup id: #{lookup[:Id]}", method: :get, suburl: "sobjects/#{soql_object_name}/#{lookup[:Id]}")
+                      else
+                        initial_query = query "SELECT Id FROM #{soql_object_name} #{soql_lookup_filter(lookup)}"
+                        data_from_url initial_query['$..url'], lookup
+                      end
+    SoqlData.ids_to_delete[self] = instance_to_get[:id] if teardown
+    instance_to_get
+  end
+
+  # @return [Exchange] Result of looking up id based on lookup criteria
+  def lookup_id(lookup)
+    teardown = lookup.delete(:teardown)
+    SoqlHandler.new("Query on #{self}").use
+    result = query "SELECT Id FROM #{soql_object_name} #{soql_lookup_filter(lookup)}", wait: false
+    SoqlData.ids_to_delete[self] = id if teardown
+    result
+  end
+
+  # @return [String] Id that matches filter
+  def id_where(lookup)
+    lookup_id(lookup).id
+  end
+
+  # @return [Boolean] Whether any result for lookup
+  def any_where?(lookup)
+    lookup_id(lookup)[:totalSize] != 0
+  end
+
+  # Perform the code in the block for all the ids matching a query.
+  # If no block, return a list of objects
+  # @param [Hash] lookup Key value pair unique to Salesforce to query for
+  # @yield [id] Perform block for each id returned. The 'id' parameter in a block represents an id matching the query
+  # @return [Array] List of ids matching criteria. Only used if no block given
+  def each_id_with(lookup)
+    lookup[:limit] ||= nil # Don't limit results returned
+    SoqlHandler.new("Each Id where #{self}").use
+    results = query "SELECT Id FROM #{soql_object_name} #{soql_lookup_filter(lookup)}", wait: false
+    ids = results.ids
+    if block_given?
+      ids.each { |id| yield(id) }
+    else
+      ids
+    end
+  end
+
+  # @param [Hash] lookup Key value pair unique to Salesforce to query for
+  # @return [Array] List of Soql objects matching criteria
+  def each_with(lookup)
+    ids = each_id_with lookup
+    ids.collect { |id| get(Id: id) }
+  end
+
+  # Remove all ids from table that match lookup criteria
+  # @param [Hash] lookup Key value pair unique to Salesforce to query for
+  def delete_ids_with(lookup)
+    each_id_with(lookup, &method(:delete))
+  end
+
+  # Remove object from Salesforce with provided id
+  # @param [String] id Id of element to update
+  # @param [Hash] data Key value pairs with data to update
+  # @return [Exchange] Exchange object for object
+  def update(id, data)
+    must_pass = data.delete(:must_pass)
+    data = data.transform_values do |value|
+      value.is_a?(Time) ? value.salesforce_format : value
+    end
+    SoqlHandler.new("Update #{id}").use
+
+    update = new("Update #{self}, #{id} with '#{data}'", method: :patch,
+                                                         suburl: "sobjects/#{soql_object_name}/#{id}", body: data)
+    update.call
+
+    return update unless must_pass
+
+    successful?
+    update
+  end
+
+  # Remove object from Salesforce with provided id
+  # @param [String] id Id of element to remove
+  # @param [Boolean] must_pass Whether to raise exception if call is not successful
+  # @return [Exchange] Exchange object making delete call
+  def delete(id, must_pass: false)
+    SoqlData.ids_to_delete.reject! { |table, id_to_remove| table == self && id_to_remove == id } # Remove id from list to delete
+    remove_dependent_records(id)
+
+    SoqlHandler.new("Delete #{id}").use
+    delete = new('SOQL Delete', method: :delete, suburl: "sobjects/#{soql_object_name}/#{id}")
+    delete.call
+    return delete unless must_pass
+
+    successful?
+    delete
+  end
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
+  def soql_element(name, backend_name)
+    # Either set the element (if creating a new record) or update the object
+    # @param [String] new_value Value to update record to
+    define_method("#{name}=") do |new_value|
+      if @response
+        @response = update(backend_name => new_value).response
+      else
+        self[backend_name] = new_value.class < SoqlData ? new_value.id : new_value
+      end
+    end
+
+    # @return [String] Value of backend name
+    define_method name.to_s do
+      begin
+        self[backend_name]
+      rescue NoElementAtPath
+        raise diagnose_error if error_message?
+
+        @response = get.response
+        self[backend_name]
+      end
+    end
+    # @return [String] Name of backend name for element
+    define_method("#{name}_element") { backend_name }
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/AbcSize
+
+  private
+
+  # @todo: Cover >= condition
+  # @param [String] value Value to search for. Certain
+  # @return [String] Condition criteria to match value
+  def condition_for(value)
+    operator = case value[0]
+               when '>' then '>'
+               when '<' then '<'
+               when '~' then 'LIKE'
+               else
+                 return "= '#{value}'" unless value.type_of_time?
+
+                 return "= #{value.to_zulu_date_string}"
+               end
+
+    value = value[1..-1]
+    return "#{operator} #{value.to_zulu_date_string}" if value.type_of_time?
+
+    "#{operator} '#{value}'"
+  end
+end

data/lib/leap_salesforce/soql_data/soql_handler.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'soaspec'
+
+# Handles basic Soql interactions.
+# Credentials are stored either in 'config/credentials' folder or via environment variables
+# To check out SOQL SCHEMA go to workbench.developerforce.com. Use Sandbox and login
+class SoqlHandler < Soaspec::RestHandler
+  oauth2 username: '<%= LeapSalesforce.api_user %>', password: LeapSalesforce.password,
+         client_id: LeapSalesforce.client_id,
+         client_secret: LeapSalesforce.client_secret,
+         token_url: "https://#{LeapSalesforce.environment == 'prod' ? 'login' : 'test'}.salesforce.com/services/oauth2/token"
+  base_url '<%= instance_url %>/services/data/v<%= api_version %>/'
+
+  pascal_keys true
+  headers authorization: 'Bearer <%= access_token %>', content_type: 'application/json'
+
+  element :success, '$..success'
+  element :error_message_element, '$..message'
+  element :soql_fields, :fields
+
+  # @return [String] Version of Salesforce API to use
+  @api_version = '45.0'
+
+  class << self
+    # @return [String] The current Salesforce instance URL obtained from oauth call
+    def instance_url
+      new.instance_url # Instance url is defined through oauth2_file method
+    end
+
+    # @return [String] Version of Salesforce API to use
+    attr_accessor :api_version
+  end
+
+  # @return [String] Version of Salesforce API to use
+  def api_version
+    SoqlHandler.api_version
+  end
+end

data/lib/leap_salesforce/soql_data/soql_object_describe.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# Methods relating to describing a soql object
+# See https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/resources_sobject_describe.htm
+# for reference.
+# Note the data here is cached. If metadata changes you would need to re run Ruby Code to get updates if a call has
+# already been made
+module SoqlObjectDescribe
+  # Reference https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/sobject_describe_with_ifmodified_header.htm
+  # @todo Get this to work
+  def changes_from_date(_date)
+    @changes_from_date ||= new("describe #{self}", method: :get, suburl: "sobjects/#{soql_object_name}/describe/",
+                                                   params: { if_modified_since: 'Wed, 3 Jul 2013 19:43:31 GMT' })
+  end
+
+  # @return [SoqlData] Retrieve JSON that describes current object
+  def description
+    @description ||= new("describe #{self}", method: :get, suburl: "sobjects/#{soql_object_name}/describe/")
+  end
+
+  def layouts
+    @layouts ||= new("layouts for #{self}",
+                     method: :get, suburl: "sobjects/#{soql_object_name}/describe/layouts")
+  end
+
+  def layouts_for(record_type_id)
+    new("layouts for #{self} on #{record_type_id}",
+        method: :get, suburl: "sobjects/#{soql_object_name}/describe/layouts/#{record_type_id}")
+  end
+
+  # @return [Array] List of fields that each are a hash of attributes
+  def fields
+    @fields ||= description[:fields]
+  end
+
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [Hash] Hash storing all properties of a field
+  def properties_for(field_name)
+    field_name = field_name.to_s
+    properties = fields.find { |field| %w[name label].any? { |label| field[label] == field_name } }
+    unless properties
+      raise LeapSalesforce::ResponseError, "Field name '#{field_name}' not found in '#{self}'" \
+      " using table name '#{soql_object_name}'. Field names are #{field_names}"
+    end
+
+    properties
+  end
+
+  # Finding Picklist values for specified fields
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [Array] List of values for passed in field_name
+  def picklist_for(field_name)
+    properties = properties_for field_name
+
+    properties['picklistValues'].collect { |list| list['label'] }
+  end
+
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [Integer] Max length of field
+  def length_for(field_name)
+    properties_for(field_name)['length']
+  end
+
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [String, nil] Default value for field provided
+  def default_for(field_name)
+    properties_for(field_name)['defaultValue']
+  end
+
+  def required
+    fields.find_all { |field| field[''] }
+  end
+
+  def picklists
+    label_names.find_all { |f| type_for(f) == 'picklist' }
+  end
+
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [String] Type of field (e.g., picklist, string, double, reference)
+  def type_for(field_name)
+    properties_for(field_name)['type']
+  end
+
+  # @param [String, Symbol] field_name Salesforce backend field name
+  # @return [String, nil] Other entity this field relates to if it's a reference field
+  def relationship_name_for(field_name)
+    properties_for(field_name)['relationshipName']
+  end
+
+  # @return [Array] Label names of object
+  def label_names
+    fields.collect { |field| field['label'] }
+  end
+
+  # @return [Array]
+  # Field values for field names
+  def field_names
+    fields.collect { |field| field['name'] }
+  end
+end

data/lib/leap_salesforce/soql_data/soql_settings.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Settings for configuring usage of Soql Objects
+module SoqlSettings
+  # Set name of soql object. This is equivalent to the name in https://workbench.developerforce.com or
+  # the lightning URL when looking at an object
+  # @param [String] name Name of Soql object
+  def soql_object(name)
+    @soql_object_name = name
+  end
+
+  # @return [String] Name of Soql object
+  def soql_object_name
+    @soql_object_name || to_s
+  end
+
+  # Whether to create enumerations for object when running generation tasks. By default this is true
+  # For some objects you may want to use them without tracking their enumerations
+  def create_enum(set)
+    @create_enum = set
+  end
+
+  # @return [Boolean] Whether to create enum for object
+  def create_enum?
+    if @create_enum.nil?
+      true # True by default
+    else
+      @create_enum
+    end
+  end
+end

data/lib/leap_salesforce/users/user.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LeapSalesforce
+  # A test user used to execute tests
+  class User
+    # @return [String] Name to identify user by
+    attr_accessor :key
+    # @return [String] Username of User interpreted by ERB (in email address format). Use ERB to define users that can vary
+    #   according to environment
+    attr_writer :username
+    # @return [String] Long form description of user. Could be used to reference them in a Cucumber test
+    attr_accessor :description
+
+    # @param [String, Symbol] key Key used to identify a test user
+    # @param [String] username Name used to login with user. In email address format.
+    def initialize(key, username, description: nil)
+      self.key = key
+      self.username = username
+      self.description = description
+    end
+
+    # @return [String] Email address of User
+    def username
+      ERB.new(@username).result(binding)
+    end
+  end
+end