administrators

You would have to load all your data into objects from the fixtures, but you could then add each response to an array and shift each time inside a while loop. Your error reporting won’t be great but you should be able to process all of your data sets with minimal code duplication. Something like this, maybe:

it(‘tests my data sets’, () => {
    const datasets = [dataset1, dataset2, dataset3];
    while(dataset.length > 0) {
        cy.intercept('GET', '/todos', req => req.reply(datasets.shift()));
        cy.get(‘items’).should(‘be.visible’);
    }
});

I want to run a single test in parallel with different data sets.
I am storing the data set in fixtures.

Some prefer to use HttpClient because it is already built into the framework. So there's no need to add extra bloat to your project.

RestSharp, like any library, is easier to use because someone already did the hard work and ironed out the problems gotten along the way.

I have used both, and the one is not better than the another. It just depends on your use-case, situation and environment.

I had a WebAPI proxy project that needed to call another REST API. I chose RestSharp at first because I was already familiar with it from using it in another project. However, I changed to HttpClient eventually because it uses the same return types as the WebAPI controllers, so it just saved me time from having to convert RestSharp's responses back to a HttpResponseMessage.

Of course each one has its pros and cons, it just boils down to your use-case.

I've been scouring the internet all day for a simple comparison, but have yet to find any up to date information regarding the subject.

I recently joined a team working on a project that is using RestSharp for all API calls. I have previously implemented an HttpClient via the CreateClient method of the .NET Core IHttpclientFactory.

I'm looking for objective pros/cons regarding each for calling REST endpoints. Is this simply a matter of preference? Is there any underlying difference in how the HttpClient lifecycle is managed between the RestSharp library and the IHttpClientFactory implementation?

I have noticed, or at least it appears to me, that I am not able to manage the incoming response on as granular a level, but for the sake of the question being asked, let's just chalk that up to my lack of experience with RestSharp.

use @BeforeMethod and @AfterMethod as following:

public class DemoTest {

    private static final Logger log = LoggerFactory.getLogger(DemoTest.class);

    @BeforeMethod
    public void before() {
        log.info("before");
    }

    @AfterMethod
    public void after() {
        log.info("after");
    }

    @Test
    public void test1() {
        log.info("test1");
    }

    @Test
    public void test2() {
        log.info("test2");
    }
}

result:

before
test1
after
before
test2
after

I try to execute the test several times with DataProvider. All works fine, but @BeforeTest and @AfterTest execute only one time, but I need this execution with each iteration.:

public class TestClass{

    @BeforeTest
    public void before(){
        Log.info("BeforeTest");
    }

    @AfterTest
    public void after(){
        Log.info("AfterTest");
    }

    @DataProvider
    public Object[][] tenTime(){
        return new Object[][]{
                {0}, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}
        };
    }
    
    private static Integer c = 0;

    @Test(dataProvider = "tenTime")
    public void tenTimesTest(Integer count){
        Assert.assertSame(count, c++);
    }
}

Actual result:

@BeforeTest and @AfterTest executes once:
[INFO] 19-01-21 11:54:47 main | BeforeTest
[INFO] 19-01-21 11:54:47 main | The tenTimesTest test started
[INFO] 19-01-21 11:54:47 main | tenTimesTest test is starting.
[INFO] 19-01-21 11:54:48 main | The tenTimesTest test succeed
[INFO] 19-01-21 11:54:48 main | tenTimesTest test is passed
[INFO] 19-01-21 11:54:48 main | The tenTimesTest test started
[INFO] 19-01-21 11:54:48 main | tenTimesTest test is starting.
[INFO] 19-01-21 11:54:48 main | The tenTimesTest test succeed
[INFO] 19-01-21 11:54:48 main | tenTimesTest test is passed
..............
[INFO] 19-01-21 11:54:50 main | AfterTest

Expected result:

@BeforeTest and @AfterTest executes each time with tenTimesTest:
[INFO] 19-01-21 11:54:47 main | BeforeTest
[INFO] 19-01-21 11:54:47 main | The tenTimesTest test started
[INFO] 19-01-21 11:54:47 main | tenTimesTest test is starting.
[INFO] 19-01-21 11:54:48 main | The tenTimesTest test succeed
[INFO] 19-01-21 11:54:48 main | tenTimesTest test is passed
[INFO] 19-01-21 11:54:50 main | AfterTest
[INFO] 19-01-21 11:54:47 main | BeforeTest
[INFO] 19-01-21 11:54:47 main | The tenTimesTest test started
[INFO] 19-01-21 11:54:47 main | tenTimesTest test is starting.
[INFO] 19-01-21 11:54:48 main | The tenTimesTest test succeed
[INFO] 19-01-21 11:54:48 main | tenTimesTest test is passed
[INFO] 19-01-21 11:54:50 main | AfterTest

Not only the server need to be able to respond fast enough, JMeter must be able to send requests fast enough as well.

Default JMeter configuration is suitable for tests development and debugging and creating some load (rather limited though), you need to properly tune your JMeter instance in order to fully utilize your machine resources
If your single machine is not powerful enough to conduct the required load it's possible to run JMeter in distributed mode using as many load generators as needed in order to create the necessary number of virtual users/requests per second

Scenario: Read data from a CSV file with unknown number of records. Use the data to create Soap XML MSg and Post Method. Continue to do this until all the records have been read.

Problem: I used ReadyAPI to perform these actions and was able to achieve the intended TPS at server with whatever i have provided in VU's option. Tried with 150 vu's and observed constant load of 150 requests at the server. But when i try to do the same in JMeter, i was not able to achieve more than 70 TPS and the load isn't evenly distributed as well no matter how many threads i use. I am using a Thread Group, CSV DataSet Config, UserDefined Parameters to create unique request ID and JSR223 PreProcessor with Groovy Script as a child of HTTPRequest to remove empty xml tags.

Read some posts where it was mentioned that JMeter throughput will be stagnant based on servers response capability. But it's not in my case since i can generate 150TPS with ReadyAPI. Annual Licensing costs and Renewal costs associated with ReadyAPI is the Reason that i am looking for solution with JMeter.

let jsonData = pm.response.json(); 
pm.environment.set("test_name", jsonData.test3[0].id3);

test3 is an array so you have to get the first object and then id3