fixturizer 0.1.0 → 0.4.1

data/lib/fixturizer/services.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Fixturizer
+  class Services
+    include Singleton
+    @@settings = Fixturizer::Settings.new
+    def self.settings
+      @@settings
+    end
+
+    def self.configure
+      yield(@@settings)
+    end
+
+    attr_reader :configuration, :log
+
+    def initialize
+      @configuration = Fixturizer::Configuration.new filename: @@settings.configuration_filename
+      @log = Logger.new(Fixturizer::Services.settings.log_target)
+      log.info 'Starting new Fixturing'
+    end
+
+    def service(type:, name:, parameters: nil)
+      service = "Fixturizer::#{type.to_s.capitalize}::#{name.to_s.capitalize}"
+      log.info "running Service : #{service}"
+      if parameters.nil?
+        Object.const_get(service).new
+      else
+        log.info "  => params : #{parameters}"
+        Object.const_get(service).new(**parameters)
+      end
+    end
+
+    def engine(name:, parameters: nil)
+      service(type: :engines, name:, parameters:)
+    end
+
+    def getter(name:, parameters: nil)
+        service(type: :getters, name:, parameters:)
+      end
+
+    def serializer(name:, parameters: nil)
+      service(type: :serializers, name:, parameters:)
+    end
+
+    class << self
+      alias get instance
+      alias init instance
+    end
+  end
+end

data/lib/fixturizer/settings.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Fixturizer
+  class Settings
+    attr_accessor :configuration_filename, :log_target, :verbose
+
+    def initialize
+      @configuration_filename = './config/rules.yml'
+      @log_target = '/tmp/fixturizer.log'
+      @verbose = false
+    end
+  end
+end

data/lib/fixturizer/version.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require 'version'
+
 module Fixturizer
-  VERSION = "0.1.0"
+  VERSION = Version.current
 end

data/lib/fixturizer.rb

@@ -1,109 +1,10 @@
-require 'mongoid'
-require "fixturizer/version"
-require 'yaml'
-
-module Fixturizer
-  module Adapters
-    module Mongoid
-      def injector(model_infos:, item:)
-        model = Object.const_get(model_infos[:class])
-        model.create!(item) unless model.where(model_infos[:unicity] => item[model_infos[:unicity]]).exists?
-      end
-
-      def binder(item:)
-        result = Hash::new
-        item.each do |element|
-          model_class = @models[element[:collection]][:class]
-          model = Object.const_get(model_class)
-          if element[:index].include?(:at)
-            result[element[:fkey]] = model.all[element[:index][:at] - 1][element[:pkey]].to_s
-          elsif element[:index].include?(:search_key)
-            raise 'Links configuration failure' unless element[:index].include?(:for)
-
-            result[element[:fkey]] = model.where({ element[:index][:search_key] => element[:index][:for] }).first[element[:pkey]]
-          else
-            raise 'Links configuration failure'
-          end
-        end
-        return result
-      end
-
-      def drop_database
-        ::Mongoid.purge!
-      end
-    end
-  end
-
-  class Engine
-    ADAPTERS = {:mongoid => ::Fixturizer::Adapters::Mongoid}
-
-    attr_reader :generated
-
-    def initialize(filename:)
-      @rules = read_rules(filename: filename)
-      @generations = @rules[:fixtures][:rules][:generation]
-      @models = @rules[:fixtures][:models][:definition]
-      @order = @rules[:fixtures][:models].include?(:order) ? @rules[:fixtures][:models][:order] : false
-      @generated = Hash::new
-      self.extend ADAPTERS[@rules[:fixtures][:type]]
-    end
-
-    def generate_from(rule:)
-      rule = @generations[rule]
-      myproc = eval("lambda { #{rule[:proc]} } ")
-      return myproc.call
-    end
-
-    def link_data
-    end
-
-    def generate_data
-      @generated.clear
-      raise 'Order field format missmatch, not an array' unless @order == false || @order.class == Array
-
-      if @order then
-        raise 'Order field size missmatch for configurate definitions' unless @order.size == @models.size
-
-        @order.each do |item|
-          raise "Definition #{item} not found in models definitions" unless @models.include?(item)
-
-          @generated[item] = generate_collection(name: item)
-        end
-      else
-        @models.each do |key, _value|
-          @generated[key] = generate_collection(name: key)
-        end
-      end
-    end
-
-    def inject_data
-      raise 'Data not generated' if @generated.empty?
-
-      @generated.each do |key, value|
-        model_infos = @models[key].dup
-        model_infos.delete(:collection)
-        value.each do |item|
-          item[:attributes].merge!(self.binder(item: item[:links])) if item.include?(:links)
-          self.injector model_infos: model_infos, item: item[:attributes]
-        end
-      end
-    end
-
-    private
-    def read_rules(filename:)
-      return YAML.load(File::readlines(filename).join)
-    end
-
-    def generate_collection(name:)
-      data = @models[name][:collection].dup
-      data.each do |item|
-
-        item[:attributes].each do |key, _value|
-          item[:attributes][key] = generate_from(rule: @models[name][:rules][key]) if @models[name].include?(:rules) && @models[name][:rules].include?(key)
-        end
-
-      end
-      return data
-    end
-  end
-end
+# frozen_string_literal: true
+
+require_relative 'dependencies'
+require_relative 'fixturizer/settings'
+require_relative 'fixturizer/configuration'
+require_relative 'fixturizer/adapters/init'
+require_relative 'fixturizer/engines/init'
+require_relative 'fixturizer/serializers/init'
+require_relative 'fixturizer/getters/init'
+require_relative 'fixturizer/services'

data/samples/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/samples/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'puma', '~> 6.4'
+gem 'rackup', '~> 2.1'
+gem 'sinatra', '~> 4.0.0'
+
+group :test, :development do
+  gem 'fixturizer', '~> 0.4.0'
+  gem 'rack-rest-rspec', '~> 0.0.3'
+  gem 'rack-test', '~> 2.0.2'
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.10.0'
+end
+
+gem 'mongoid', '~> 9.0'

data/samples/Rakefile

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rspec/core/rake_task'
+require_relative 'app'
+
+RSpec::Core::RakeTask.new do |task|
+  task.pattern = 'spec/**/*_spec.rb'
+end
+
+desc 'List defined routes'
+task :routes do
+  Application.routes.map do |method, routes|
+    routes.map { |r| r.first.to_s }.map do |route|
+      "#{method.rjust(7, ' ')} #{route}"
+    end
+  end.flatten.sort.each do |route|
+    puts route
+  end
+end
+
+require 'fixturizer/rake/manage'
+
+
+Fixturizer::Services.configure do |settings|
+  settings.configuration_filename = './config/rules.yml'
+  settings.log_target = '/tmp/fixturizer.log'
+  settings.verbose = (ENV['VERBOSE'])? true : false
+end

data/samples/app.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'sinatra'
+require 'mongoid'
+
+Mongoid.configure do |config|
+  config.clients.default = {
+    uri: 'mongodb://localhost:27017/testbase'
+
+  }
+  config.belongs_to_required_by_default = false
+end
+
+class Post
+  include Mongoid::Document
+  field :title, type: String
+  field :body, type: String
+  has_many :comments
+end
+
+class Comment
+  include Mongoid::Document
+  field :name, type: String
+  field :message, type: String
+  belongs_to :post
+end
+
+class Application < Sinatra::Base
+  before do
+    content_type 'application/json'
+  end
+
+  get '/posts' do
+    Post.all.to_json
+  end
+
+  get '/posts/:post_id' do |post_id|
+    post = Post.find(post_id)
+    post.attributes.merge(
+      comments: post.comments
+    ).to_json
+  end
+end

data/samples/config/rules.yml

@@ -0,0 +1,52 @@
+---
+:fixtures:
+  :datasets:
+    :myset:
+      :definition:
+        - :name: test dataset
+          :list:
+            - 1
+            - :body: 
+            - 3
+          :nested:
+            :body:
+        - "two" 
+      :rules:
+        :body: :body
+  :rules:
+    :body: 
+      :proc: "SecureRandom.urlsafe_base64(64)"
+    :preserve_body:
+      :preserve: true
+      :proc: "SecureRandom.urlsafe_base64(64)"
+  :models:
+    :type: :mongoid
+    :order:
+      - :posts
+      - :comments
+    :definitions:
+      :posts:
+        :rules:
+          :body: :preserve_body
+        :class: Post
+        :unicity: :id
+        :collection:
+          - :attributes:
+              :title: First post Title
+              :body: First Post Body
+          - :attributes:
+              :title: Second post Title
+              :body: 
+      :comments:
+        :class: Comment
+        :unicity: :id
+        :collection:
+          - :attributes:
+              :name: test name
+              :message: test message
+            :links:
+              - :collection: :posts
+                :index:
+                  :at: 1
+                :fkey: :post
+                :pkey: :id

data/samples/config.ru

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+
+require './app'
+
+run Application

data/samples/spec/app_spec.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Test Fixturizer' do
+  context 'Records : test fixturizing' do
+    it 'must be possible to apply non preserving rule by definition' do
+      value = 'placeholder'
+      rule = { proc: 'SecureRandom.urlsafe_base64(64)' }
+      expect(record.apply(value:, rule:).size).to be(86)
+    end
+
+    it 'must be possible to apply preserving rule by definition' do
+      value = 'present value'
+      rule = { proc: 'SecureRandom.urlsafe_base64(64)', preserve: true }
+      expect(record.apply(value:, rule:)).to be(value)
+    end
+
+    it 'must be possible to apply rule by name (in configuration)' do
+      value = 'present value'
+      rule = :body
+      expect(record.apply(value:, rule:).size).to be(86)
+    end
+  end
+
+  context 'Datasets : test fixturizing' do
+    it 'must be possible to generate result for dataset by definition with named rule' do
+      dataset = { definition: { name: 'test dataset', body: 'placeholder' }, rules: { body: :body } }
+      result =  datasets.generate(dataset:)
+      expect(result[:body].size).to be(86)
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for dataset by definition with defined rule' do
+      dataset = { definition: { name: 'test dataset', body: 'placeholder' },
+                  rules: { body: { proc: 'SecureRandom.urlsafe_base64(64)' } } }
+      result =  datasets.generate(dataset:)
+      expect(result[:body].size).to be(86)
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for dataset by definition with named rule and nil field' do
+      dataset = { definition: { name: 'test dataset', body: nil },
+                  rules: { body: :body } }
+      result =  datasets.generate(dataset:)
+      expect(result[:body].size).to be(86)
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for dataset by definition with named preserving rule' do
+      dataset = { definition: { name: 'test dataset', body: 'test preserved' },
+                  rules: { body: :preserve_body } }
+      result =  datasets.generate(dataset:)
+      expect(result[:body]).to eq('test preserved')
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for nested dataset by definition with named rule' do
+      dataset = { definition: { name: 'test dataset', nested: { body: nil } },
+                  rules: { body: :body } }
+      result =  datasets.generate(dataset:)
+      expect(result[:nested][:body].size).to be(86)
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for complex dataset by definition with named rule' do
+      dataset = { definition: { name: 'test dataset', list: [1, { body: nil }, 3], nested: { body: nil } },
+                  rules: { body: :body } }
+      result =  datasets.generate(dataset:)
+      expect(result[:nested][:body].size).to be(86)
+      expect(result[:list].size).to be(3)
+      expect(result[:list][1][:body].size).to be(86)
+      expect(result[:name]).to eq('test dataset')
+    end
+
+    it 'must be possible to generate result for complex dataset by name with named rule' do
+      result =  datasets.generate dataset: :myset
+      expect(result[0][:nested][:body].size).to be(86)
+      expect(result[0][:list].size).to be(3)
+      expect(result[0][:list][1][:body].size).to be(86)
+      expect(result[0][:name]).to eq('test dataset')
+      expect(result.last).to eq('two')
+    end
+  end
+
+  # context 'Database : drop and populate' do
+  #   it 'must be possible to drop database with helper ' do
+  #     expect(database.drop).to be true
+  #   end
+  #   it 'must be possible to populate database with helper ' do
+  #     expect(database.populate).to be true
+  #   end
+
+  #   it { expect(database).to be_correctly_dropped }
+  #   it { expect(database).to be_correctly_populated }
+  # end
+
+  context 'Serializers : test ' do
+    it 'must be possible to serialize data to JSON' do
+      data = { name: 'test data', body: 'placeholder' }
+      result = serialize.to(format: :json, data:)
+      expect(result).to be_an_instance_of(String)
+      expect(result.size).to eq(51)
+    end
+
+    it 'must be possible to serialize data to JSON in raw format' do
+      data = { name: 'test data', body: 'placeholder' }
+      result = serialize.to format: :json, data:, raw: true
+      expect(result).to be_an_instance_of(String)
+      expect(result.size).to eq(41)
+    end
+
+    it 'must be possible to serialize data to JSON and write in a file' do
+      data = { name: 'test data', body: 'placeholder' }
+      filename = '/tmp/test.json'
+      serialize.to format: :json, data:, to_file: filename
+      expect(File.exist?(filename)).to eq true
+      File.unlink(filename)
+    end
+
+    it 'must be possible to serialize data to YAML' do
+      data = { name: 'test data', body: 'placeholder' }
+      result = serialize.to(format: :yaml, data:)
+      expect(result).to be_an_instance_of(String)
+      expect(result.size).to eq(40)
+    end
+
+    it 'must be possible to serialize data to YAML and write in a file' do
+      data = { name: 'test data', body: 'placeholder' }
+      filename = '/tmp/test.yml'
+      serialize.to format: :yaml, data:, to_file: filename
+      expect(File.exist?(filename)).to eq true
+      File.unlink(filename)
+    end
+  end
+
+
+  context 'Getters : test ' do
+    it 'must be possible to get content data from YAML file' do
+      filename = './spec/fixtures/data.yml'
+      result = get_content.from file: filename, format: :yaml
+      expect(result[:body]).to eq "test Body"
+      expect(result[:list].size).to eq 3
+    end
+
+    it 'must be possible to get content data from YAML file without symbols keys' do
+      filename = './spec/fixtures/data.yml'
+      result = get_content.from file: filename, format: :yaml, symbolize: false
+      expect(result["body"]).to eq "test Body"
+      expect(result["list"].size).to eq 3
+    end
+
+    it 'must be possible to get content data from JSON file' do
+      filename = './spec/fixtures/data.json'
+      result = get_content.from file: filename, format: :json
+      expect(result[:body]).to eq "test Body"
+      expect(result[:list].size).to eq 3
+    end
+
+    it 'must be possible to get content data from JSON file without symbols keys' do
+      filename = './spec/fixtures/data.json'
+      result = get_content.from file: filename, format: :json, symbolize: false
+      expect(result["body"]).to eq "test Body"
+      expect(result["list"].size).to eq 3
+    end
+
+  end
+
+
+end

data/samples/spec/fixtures/data.json

@@ -0,0 +1,10 @@
+{
+    "body": "test Body",
+    "list": [
+      "one",
+      2,
+      {
+        "three": 3
+      }
+    ]
+}

data/samples/spec/fixtures/data.yml

@@ -0,0 +1,6 @@
+---
+body: test Body
+list: 
+  - "one"
+  - 2
+  - {three: 3}

data/samples/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'fixturizer/rspec/prepare'
+
+Fixturizer::Services.configure do |settings|
+  settings.configuration_filename = './config/rules.yml'
+  settings.log_target = '/tmp/fixturizer.log'
+end
+
+require_relative '../app'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end