Why are you putting your list into Map? Code looks weird. If you want to return a list, just do it:

@RequestMapping("/getGodowns")
public @ResponseBody List<CscGodownBean> getGodownsBasedOnDistrict(@RequestParam(value="district_code") String dist_code) {
    List<CscGodownBean> godown_list = null;
    String exception = null;
    try {
        //getting name and codes here
        godown_list = scm_service.getGodownListBesedOnDistCode(dist_code);
    } catch (Exception ex) {
        ex.printStackTrace();
        exception = ex.getMessage();
    }
    return godown_list;
}

You need to assign returned json value to String object and then pass it to ModelAndView. Refer Gson.toJson() and also make sure your class(EmployeeBean) is serializable.

@RequestMapping(value = "/employees1", method = RequestMethod.GET)
public ModelAndView employeelist() {
    Gson gson = new Gson();
    String json = gson.toJson(employeeService.listEmployeess());

    ModelAndView modelAndView = new ModelAndView();
    modelAndView.addObject(json);

    return modelAndView;
}

Here is the code that works for me. The key is that you need a wrapper class.

public class Person {

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

A PersonWrapper class

public class PersonWrapper {

    private List<Person> persons;

    /**
     * @return the persons
     */
    public List<Person> getPersons() {
        return persons;
    }

    /**
     * @param persons the persons to set
     */
    public void setPersons(List<Person> persons) {
        this.persons = persons;
    }
}

My Controller methods

@RequestMapping(value="person", method=RequestMethod.POST,consumes="application/json",produces="application/json")
    @ResponseBody
    public List<String> savePerson(@RequestBody PersonWrapper wrapper) {
        List<String> response = new ArrayList<String>();
        for (Person person: wrapper.getPersons()){
        personService.save(person);
         response.add("Saved person: " + person.toString());
    }
        return response;
    }

The request sent is json in POST

{"persons":[{"name":"shail1","age":"2"},{"name":"shail2","age":"3"}]}

And the response is

["Saved person: Person [name=shail1, age=2]","Saved person: Person [name=shail2, age=3]"]

It seems to me that the issue is that you are trying to pass something like the following JSON to the content:

[
  {
    "compania1_list": "Compania1 list",
    "name1": "name1",
    "s": "---",
    "s1": "---",
    "o": null,
    "o1": null
  },
  {
    "compania1_list": "Compania2 list",
    "name1": "name2",
    "s": "---",
    "s1": "---",
    "o": null,
    "o1": null
  }
]

This is a JSON Array with 2 JSON Objects and not a JSON Object with a JSON Array with 2 JSON Objects. My guess is that MockHttpServletRequestBuilder.content() method is not expecting JSON like this.

With this being said, I would change your Controller to accept an Object and not a Collection as follows:

@ResponseStatus(HttpStatus.CREATED)
@PostMapping("/lista")
public Map<String, Object> createCompanias(@RequestBody CompaniasCreationRequest companiasCreationRequest) {
    return companiaService.postListCompanias(companiasCreationRequest.getCompanias());
}

Being CompaniasCreationRequest as follows:

public class CompaniasCreationRequest {
    private List<Compania> companias;

    public CompaniasCreationRequest(List<Compania> companias) {
        this.companias = companias;
    }

    public List<Compania> getCompanias() {
        return companias;
    }

    public void setCompanias(List<Compania> companias) {
        this.companias = companias;
    }
}

In your test this would mean the following changes:

@Test
void successSavePostCompaniaLista() throws Exception {
    Compania c1 = new Compania("Compania1 list",
        "name1",
        "---",
        "---",
        null,
        null);
    Compania c2 = new Compania("Compania2 list",
        "name2",
        "---",
        "---",
        null,
        null);

    CompaniasCreationRequest companiasCreationRequest = new CompaniasCreationRequest(List.of(c1,c2));
    
    when(companiaRepository.save(any(Compania.class))).then(returnsFirstArg());

    this.mockMvc.perform(
            post("/companias/lista")
                .header("authorization", "Bearer " + token)
                .content(asJsonString(companiasCreationRequest))
                .contentType(MediaType.APPLICATION_JSON))
        .andDo(print())
        .andExpect(status().isCreated())
        .andExpect(jsonPath("$.result[0].success[0]").isNotEmpty())
        .andExpect(jsonPath("$.result[0].success[0].name").value(c1.getName()))
        .andExpect(jsonPath("$.result[0].success[1].name").value(c2.getName()));
}

Now your request body will look like the following (which is a somewhat more standard JSON format):

{
  "companias": [
    {
      "compania1_list": "Compania1 list",
      "name1": "name1",
      "s": "---",
      "s1": "---",
      "o": null,
      "o1": null
    },
    {
      "compania1_list": "Compania2 list",
      "name1": "name2",
      "s": "---",
      "s1": "---",
      "o": null,
      "o1": null
    }
  ]
}

That might be because of no @RequestMapping annotation on controller. Spring boot needs mapping to figure out which method needs to be called when a REST API request is sent. E.g. You need the following on UnitController class:

@RestController
@RequestMapping(produces = MediaType.APPLICATION_JSON_UTF8_VALUE, value = "/units")
public class UnitController {

If your controller class already has that, then you need to define another mapping for methods, specifying request method and optionally, mapping. E.g.

@RestController
@RequestMapping(produces = MediaType.APPLICATION_JSON_UTF8_VALUE, value = "/units")
public class UnitController {

   @RequestMapping(method = RequestMethod.GET)
   public List<Unit> method1(){..}

   @RequestMapping(method = RequestMethod.POST)
   public List<Unit> method2(){..}

   @RequestMapping(method = RequestMethod.GET, value = "/unit")
   public List<Unit> method3(){..}
}

For the above example:

• Sending a GET request to /units will result in invocation of method1
• Sending a POST request to /units will result in invocation of method2
• Sending a GET request to /units/unit will result in invocation of method3

If your application.properties file has server.contextPath property defined then it needs to be appended to the baseurl, e.g. <host>:<port>/<contextPath>

@ResponseBody should return a JSON object but here is what you can try:

public @ResponseBody ArrayList<YourObject>
    myFunction(HttpServletResponse response) {
    response.setContentType("application/json");     
    return yourArrayList;`
}

You can also try returning a Map instead. Keep your return type as Map <String, Object> and put your ArrayList in the map. This will also work.

Try to add @ResponseBody in method declaration:

public @ResponseBody List getClients()

For Jackson you have to create a strongly typed list class because of type erasure:

public class EnquiryList extends ArrayList<Enquiry> {
}

Then return this list from your controller:

@RequestMapping(value = "/viewSearchEnquiriesAjax", method = RequestMethod.GET, headers = "Accept=application/json")
public @ResponseBody EnquiryList getEnquiriesBySearchAjax(@RequestParam String name) {
    EnquiryList list = new EnquiryList();
    ...
    return list;
}

Also check out this answer on a similar question.

The JSON response you are getting is invalid - I recommend validate JSON using - [JSON Formatter]

Here is the code for your solution, Change siteInfo[i].cardName with whatever value you want to use e.g. cardName, id... (i used cardName in below code).

Enjoy! :)

var siteInfo =
  [
    {
      "createdAt": "2021-08-21T05:04:45.000+00:00",
      "updatedAt": "2021-08-21T05:04:45.000+00:00",
      "id": 1,
      "cardName": "Demon Fiend"
    },
    {
      "createdAt": "2021-08-21T05:04:58.000+00:00",
      "updatedAt": "2021-08-21T05:04:58.000+00:00",
      "id": 2,
      "cardName": "Stack"
    },
    {
      "createdAt": "2021-08-21T05:05:00.000+00:00",
      "updatedAt": "2021-08-21T05:05:00.000+00:00",
      "id": 3,
      "cardName": "Overflow"
    }
  ]

var map = new Map();
for(var i=0; i<siteInfo.length; i++) {
  map.set(siteInfo[i].cardName, siteInfo[i]);
}
let jsonObject = {}; 
  map.forEach((value, key) => {  
    jsonObject[key] = value  
  });  
  console.log(JSON.stringify(jsonObject));