cirandas.net

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

ENV["RAILS_ENV"] = "test"

require_relative '../config/environment'

require 'rails/test_help'

require 'mocha'
require 'mocha/mini_test'
require 'minitest/spec'
require 'minitest/reporters'
Minitest::Reporters.use! Minitest::Reporters::ProgressReporter.new, ENV, Minitest.backtrace_filter

require_relative 'mocks/environment'
require_relative 'mocks/profile'
require_relative 'mocks/test_controller'
require_relative 'mocks/uploaded_file'

require_relative 'support/should'
require_relative 'support/factories'
require_relative 'support/integration_test'
require_relative 'support/controller_test_case'
require_relative 'support/authenticated_test_helper'
require_relative 'support/action_tracker_test_helper'
require_relative 'support/noosfero_doc_test'
require_relative 'support/performance_helper'
require_relative 'support/noosfero_test_helper'

plugins_factories = Dir.glob(File.join(Rails.root, 'config', 'plugins', '*','test', 'factories.rb'))
plugins_factories.each { |f| require f.sub(/\.rb$/, '') }

FileUtils.rm_rf(Rails.root.join('index', 'test'))

Image.attachment_options[:path_prefix] = 'test/tmp/public/images'
Thumbnail.attachment_options[:path_prefix] = 'test/tmp/public/thumbnails'

FastGettext.add_text_domain 'noosferotest', :type => :chain, :chain => []
FastGettext.default_text_domain = 'noosferotest'

class ActiveSupport::TestCase
  # Transactional fixtures accelerate your tests by wrapping each test method
  # in a transaction that's rolled back on completion.  This ensures that the
  # test database remains unchanged so your fixtures don't have to be reloaded
  # between every test method.  Fewer database queries means faster tests.
  #
  # Read Mike Clark's excellent walkthrough at
  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
  #
  # Every Active Record database supports transactions except MyISAM tables
  # in MySQL.  Turn off transactional fixtures in this case; however, if you
  # don't care one way or the other, switching from MyISAM to InnoDB tables
  # is recommended.
  self.use_transactional_fixtures = true

  # Instantiated fixtures are slow, but give you @david where otherwise you
  # would need people(:david).  If you don't want to migrate your existing
  # test cases which use the @david style and don't mind the speed hit (each
  # instantiated fixtures translates to a database query per test method),
  # then set this back to true.
  self.use_instantiated_fixtures  = false

  extend Test::Should

  include ActionDispatch::TestProcess
  include Noosfero::Factory
  include AuthenticatedTestHelper
  include PerformanceHelper

  fixtures :environments, :roles

  def self.all_fixtures
    Dir.glob(Rails.root.join('test', 'fixtures', '*.yml')).each do |item|
      fixtures File.basename(item).sub(/\.yml$/, '').to_s
    end
  end

  # deprecated on minitest
  def assert_block message=nil
    assert message || 'yield' do
      yield
    end
  end
  alias_method :ok, :assert_block

  setup :global_setup

  def global_setup
    User.current = nil
  end

  alias_method :ok, :assert_block

  def assert_equivalent(enum1, enum2)
    norm1 = enum1.group_by{|e|e}.values
    norm2 = enum2.group_by{|e|e}.values
    assert_equal norm1.size, norm2.size, "Size mismatch: #{enum1.inspect} vs #{enum2.inspect}"
    assert_equal [], norm1 - norm2, "Arrays #{norm1} and #{norm2} are not equivalents"
    assert_equal [], norm2 - norm1, "Arrays #{norm1} and #{norm2} are not equivalents"
  end

  def assert_mandatory(object, attribute, test_value = 'some random string')
    object.send("#{attribute}=", nil)
    object.valid?
    assert object.errors[attribute.to_s].present?, "Attribute \"#{attribute.to_s}\" expected to be mandatory."
    object.send("#{attribute}=", test_value)
    object.valid?
    assert !object.errors[attribute.to_s].present?, "Attribute \"#{attribute.to_s}\" expected to accept value #{test_value.inspect}"
  end

  def assert_optional(object, attribute)
    object.send("#{attribute}=", nil)
    object.valid?
    assert !object.errors[attribute.to_s].present?
  end

  # this check only if text has html tag
  def assert_sanitized(text)
    assert !text.index('<'), "Text '#{text}' expected to be sanitized"
  end

  # TODO: HTML::Document is deprecated, port to Nokogiri::HTML
  def assert_tag_in_string(text, options)
    doc = HTML::Document.new(text, false, false)
    tag = doc.find(options)
    assert tag, "expected tag #{options.inspect}, but not found in #{text.inspect}"
  end

  def assert_no_tag_in_string(text, options)
    doc = HTML::Document.new(text, false, false)
    tag = doc.find(options)
    assert !tag, "expected no tag #{options.inspect}, but tag found in #{text.inspect}"
  end

  def assert_order(reference, original)
    original.each do |value|
      if reference.include?(value)
        if reference.first == value
          reference.shift
        else
          assert false, "'#{value.inspect}' was found before it should be on: #{original.inspect}"
        end
      end
    end
    assert reference.blank?, "The following elements are not in the collection: #{reference.inspect}"
  end

  def h2s(value) # make a string from ordered hash to simplify tests
    case value
      when Hash, HashWithIndifferentAccess
        '{'+ value.stringify_keys.to_a.sort{|a,b|a[0]<=>b[0]}.map{ |k,v| k+':'+h2s(v) }.join(',') +'}'
      when Array
        '['+ value.map{|i|h2s(i)}.join(',') +']'
      when NilClass
        '<nil>'
      else value.to_s
    end
  end

  # For models that render views (blocks, articles, ...)
  def self.action_view
    @action_view ||= begin
      view_paths = ActionController::Base.view_paths
      action_view = ActionView::Base.new view_paths, {}
      # for using Noosfero helpers inside render calls
      action_view.extend ApplicationHelper
      action_view
    end
  end

  def render *args
    self.class.action_view.render(*args)
  end

  def url_for args = {}
    args
  end

  # url_for inside views (partials)
  # from http://stackoverflow.com/a/13704257/670229
  ActionView::TestCase::TestController.instance_eval do
    helper Noosfero::Application.routes.url_helpers
  end
  ActionView::TestCase::TestController.class_eval do
    def _routes
      Noosfero::Application.routes
    end
  end

  private

  def uses_host(name)
    #@request.instance_variable_set('@host', name)
    @request.host = name
  end

  def process_delayed_job_queue
    silence_stream STDOUT do
      Delayed::Worker.new.work_off
    end
  end

  def uses_postgresql(schema_name = 'test_schema')
    adapter = ApplicationRecord.connection.class
    adapter.any_instance.stubs(:adapter_name).returns('PostgreSQL')
    adapter.any_instance.stubs(:schema_search_path).returns(schema_name)
    Noosfero::MultiTenancy.stubs(:on?).returns(true)
  end

  def uses_sqlite
    adapter = ApplicationRecord.connection.class
    adapter.any_instance.stubs(:adapter_name).returns('SQLite')
    Noosfero::MultiTenancy.stubs(:on?).returns(false)
  end

  def unsafe(string)
    ret = ActiveSupport::SafeBuffer.new(string)
    ret.instance_eval { @html_safe = false }
    ret
  end

  def json_response
    ActiveSupport::JSON.decode(@response.body)
  end

  def set_profile_field_privacy(profile, field, privacy = 'private_content')
    environment = profile.environment
    environment.send("custom_#{profile.type.downcase}_fields=", { field => { 'active' => 'true' } })
    environment.save!
    profile.fields_privacy =  { field => privacy }
    profile.save!
  end

  def create_base64_image
    image_path = File.absolute_path(Rails.root + 'public/images/noosfero-network.png')
    image_name = File.basename(image_path)
    image_type = "image/#{File.extname(image_name).delete "."}"
    encoded_base64_img = Base64.encode64(File.open(image_path) {|io| io.read })
    base64_image = {}
    base64_image[:tempfile] = encoded_base64_img
    base64_image[:filename] = image_name
    base64_image[:type] = image_type
    base64_image
  end

end