I'm trying to test a component in unit tests. problem I have is with database calls. I get error saying that association is not declared in my table class. But association is there, I checked by pasting code to AppController which returns data correctly.
How can I test my component code when I use associations in my query builder.
Looks like generic tableClass is used instead of my declared table class?
Related
Im trying to get familiar with using MOQ and mocking in general. So I want to test an api controller which uses an assembly which serves as a repository for getting/updating data etc.
eg a structure like this.
HomeController
Index
Repository.GetSomeData (returns JSON object)
This repository class has an interface, and that is what is injected via the .net core startup class. The method in this case, GetSomeData does a number of steps via calls to the Db, as well as reading a file from the file system, parsing it and moving it off to another folder.
Question: How can a "mocked" Repository work without doing the things that the "real" object does? All the examples I see are simple addition, returning strings etc.
When you mock something like your repository, you going to stub out methods on the repository to return some canned result. Calls to those methods on the repository mock, then, bypass the real methods and instead just do what you've stubbed.
Essentially, you need to first identity what methods will be utilized. Then, you should determined appropriate responses those methods should return based on the particular scenario you're attempting to unit test. Then, you create the mock and add stubs for those methods with those responses.
The whole point of mocking is to remove variables, so you're intentionally trying to get to the "happy path": the set of internal responses that put the action in the state you need it to be in for specific test you're conducting.
I have one question. I've started to use CanJS just recently and trying to create unit tests (funcunit / jasmine ) that will work in maven build with TeamCity (headless).
It was relatively easy to test Model, because it doesn't rely on any view and you can create instance and test functionality.
But it not so clear for me how to test Components and other parts of CanJS. Just to clarify i don't need E2E tests with user interaction, what i'm trying to achieve is just have some data provided by Can.fixtures and then just test that my functions works fine by calling them in tests.
Controller tests benefit from the addition of jasmine-fixture to your Jasmine test bed. You can affix() the appropriate DOM elements and instantiate the controller in beforeEach() before adding spies to the instance or the controller prototype, then fire events or directly call functions requiring some DOM tree to be available.
For Components, there's one more step involved. Because of the way Components are instantiated, either you have to use can.view() to create and attach their custom elements to the DOM (and clean it up in afterEach()), or you have to use can.view.callbacks.tagHandler(el, tag_name) to manually instantiate the Component for an element already in the DOM.
To be clear, this makes things easier when your controller/component functions are slurping data from the DOM, as in event handlers. It also works to just call the functions directly on the prototype and make spy objects for this.scope and this.options
I am sorry if this question is already been asked. I am very new to Unit Testing and I am suppose to use Rhino for mocking.
So the problem is...I have a method to test and that method is suppose to do retrive some data based on input parameter and return as datatable.
It also do some calculation for finding out which stored procedure should be called and with which set of parameters.
I issue is that, When I call the method with mock objects....it throws an error at date from database retrival line of code as object is not set to an instanse. That is expected as their is no data retruning from database since we are mocking it.
so what could be done it that case.
Seems like it is a good time to introduce Repository Pattern.
If you introduce than, the logic to generate query to DB and the logic to read data from DB will be encapsulated in the Repository.
In this case you can mock/stub the Repository in your tests and you can unit test all the classes, which use Repository, without creation test DB at all.
The Repository mock will verify whether incoming parameters are correct.
And the Repository stub will return any test-specific data which you need for each particular test.
I haven't written unit testing with JS before and I'm still learning ember and javascript in general, so forgive the question for its simplicity.
Ember apps are structured by first creating a namespace for the app like so:
MyApp = Ember.Application.create({...})
Then you'd define a model like so:
MyApp.SomeModel = DS.Model.extend({...})
But when I'm writing a unit test for SomeModel, it doesn't seem right to instantiate an Ember.Application instance when you're just unit testing a model, especially with all the Router injections and such going on behind the scenes.
However, to define the model you need the app namespace, MyApp.SomeModel .. and that app name space is created when the Application is instantiated (if you follow the Ember namespace convention).
So how do you unit test a model without instantiating the app? Do you create a mock for the app namespace?
I'm using jasmine btw.
I create a dummy instance of Ember.Application. It's not particularly costly to do.
I'm trying to write unit tests for parts of my Node app. I'm using Mongoose for my ORM.
I've searched a bunch for how to do testing with Mongoose and Node but not come with anything. The solutions/frameworks all seem to be full-stack or make no mention of mocking stuff.
Is there a way I can mock my Mongoose DB so I can return static data in my tests? I'd rather not have to set up a test DB and fill it with data for every unit test.
Has anyone else encountered this?
I too went looking for answers, and ended up here. This is what I did:
I started off using mockery to mock out the module that my models were in. An then creating my own mock module with each model hanging off it as a property. These properties wrapped the real models (so that child properties exist for the code under test). And then I override the methods I want to manipulate for the test like save. This had the advantage of mockery being able to undo the mocking.
but...
I don't really care enough about undoing the mocking to write wrapper properties for every model. So now I just require my module and override the functions I want to manipulate. I will probably run tests in separate processes if it becomes an issue.
In the arrange part of my tests:
// mock out database saves
var db = require("../../schema");
db.Model1.prototype.save = function(callback) {
console.log("in the mock");
callback();
};
db.Model2.prototype.save = function(callback) {
console.log("in the mock");
callback("mock staged an error for testing purposes");
};
I solved this by structuring my code a little. I'm keeping all my mongoose-related stuff in separate classes with APIs like "save", "find", "delete" and no other class does direct access to the database. Then I simply mock those in tests that rely on data.
I did something similar with the actual objects that are returned. For every model I have in mongoose, I have a corresponding class that wraps it and provides access-methods to fields. Those are also easily mocked.
Also worth mentioning:
mockgoose - In-memory DB that mocks Mongoose, for testing purposes.
monckoose - Similar, but takes a different approach (Implements a fake driver). Monckoose seems to be unpublished as of March 2015.