Q:

Is there a way in AngularJs to test controllers with Services and only mock\stub things like $http?

I'd like to test from my controller down through my various services and back and only stub the data that is being returned from calls to $http. 
This is an approach I use in C# with IoC containers where I only override the dependencies that you want to stub for the test and leave everything else as is.
Is there a way to do this in AngularJs tests with Jasmine so that I can increase the scope of my tests to be greater than a single controller or service?
Edit
Below is an example to clarify the approach I want to use. 
angular.module('app')
    .service('aController', [
        'servcieB',
        'serviceC',
        function ($scope, serviceB, serviceC) {

            serviceC.doHttpSomething().then(function (result) {

                    $scope.bSomething = serviceB.doSomething(result);
            });

        }
    ])
    .service('serviceB', function () {

        function doSomething(input) {

            return input + ' with something';
        };

        return {
            doSomething: doSomething
        }
    })
    .service('serviceC', [
        '$http',
        function (http) {

            function doHttpSomething() {
                return http.get('/something');
            };

            return {
                doHttpSomething: doHttpSomething
            }
        }]);

In the contrived code above I'd like to be able to write one test that tests aController, serviceB and serviceC while only mocks $http. On the $http mock I'd want to verify that serviceC called it correctly and then be able to return dummy data that I can then verify was processed correctly by serviceB and set correctly to the scope by aController by only checking that the expected result on $scope.bSomething is correct. 
I know how to test each component separately in isolation but I want to test them all together as I want to write fewer tests and only want to verify that the overall desired behavior is correct. In c# this approach allows me to change the implementation details without having to rewrite a bunch of tests and I'd like to accomplish the same workflow here if possible.
Edit 2 - Working solution below
Based on William's feedback I created a FiddleJs with a working example that models my situation of having 2 layers of services (Domain and DAL) and only mocking the $http in the DAL services.
Fiddle Example
//--- Js CODE --------------------------
angular.module('app', [])
    .controller('MainController', function ($scope, $log, BlogService) {
    $scope.username = 'Bret';
    $scope.posts = [];

    BlogService.getPostByUserName($scope.username).then(

    function (response) {

        $log.debug('MainController.getPostByUserName reponse.length: ' + response.length);

        for (var i = 0; i < response.length; i++) {
            $scope.posts.push(response[i]);
        }
    });
})
    .factory('BlogService', function ($q, $log, PostService, UserService) {

    function getPostByUserName(userName) {
        var deffered = $q.defer();

        UserService.getUserByUserName(userName).then(

        function (user) {

            $log.debug('BlogService.getUserByUserName.then user:' + user + ' user.id: ' + user.id);

            PostService.getPosts().then(

            function (posts) {
                var postsByUser = [];

                for (var i = 0; i < posts.length; i++) {
                    if (posts[i].userId === user.id) {
                        postsByUser.push(posts[i]);
                    }
                }

                deffered.resolve(postsByUser);
            },

            function (error) {
                deffered.reject(error);
            });
        });

        return deffered.promise;
    };

    return {
        getPostByUserName: getPostByUserName
    };
})
    .factory('PostService', function ($http, $q) {

    function getPosts() {
        var deffered = $q.defer();

        $http.get('http://jsonplaceholder.typicode.com/posts')
            .success(function (response) {
            deffered.resolve(response);
        })
            .error(function (error) {
            deferred.reject(error);
        });

        return deffered.promise;
    };

    return {
        getPosts: getPosts
    };
})
    .factory('UserService', function ($http, $q) {

    function getUserByUserName(userName) {
        var deffered = $q.defer();

        $http.get('http://jsonplaceholder.typicode.com/users')
            .success(function (response) {

            var user;

            for (var i = 0; i < response.length; i++) {
                if (response[i].username === userName) {
                    user = response[i];
                    break;
                }
            }

            deffered.resolve(user);
        })
            .error(function (error) {
            deferred.reject(error);
        });

        return deffered.promise;
    };

    return {
        getUserByUserName: getUserByUserName
    };
});

//--- SPECS -------------------------
describe('app', function () {

    var endpointController;

    var dummyPosts = [
  {
    "userId": 1,
    "id": 1,
    "title": "sunt aut facere repellat provident occaecati excepturi optio reprehenderit",
    "body": "quia et suscipit\nsuscipit recusandae consequuntur expedita et cum\nreprehenderit molestiae ut ut quas totam\nnostrum rerum est autem sunt rem eveniet architecto"
  }];

    var dummyUsers = [
  {
    "id": 1,
    "name": "Leanne Graham",
    "username": "Bret",
    "email": "Sincere@april.biz",
    "address": {
      "street": "Kulas Light",
      "suite": "Apt. 556",
      "city": "Gwenborough",
      "zipcode": "92998-3874",
      "geo": {
        "lat": "-37.3159",
        "lng": "81.1496"
      }
    },
    "phone": "1-770-736-8031 x56442",
    "website": "hildegard.org",
    "company": {
      "name": "Romaguera-Crona",
      "catchPhrase": "Multi-layered client-server neural-net",
      "bs": "harness real-time e-markets"
    }
  },
  {
    "id": 2,
    "name": "Ervin Howell",
    "username": "Antonette",
    "email": "Shanna@melissa.tv",
    "address": {
      "street": "Victor Plains",
      "suite": "Suite 879",
      "city": "Wisokyburgh",
      "zipcode": "90566-7771",
      "geo": {
        "lat": "-43.9509",
        "lng": "-34.4618"
      }
    },
    "phone": "010-692-6593 x09125",
    "website": "anastasia.net",
    "company": {
      "name": "Deckow-Crist",
      "catchPhrase": "Proactive didactic contingency",
      "bs": "synergize scalable supply-chains"
    }
  }];

    beforeEach(module('app'));

    it('should return posts by bret ', inject(function ($rootScope, $controller, $httpBackend) {
        var scope = $rootScope.$new();  

 $httpBackend.expectGET('http://jsonplaceholder.typicode.com/users')
            .respond(dummyUsers);
        $httpBackend.expectGET('http://jsonplaceholder.typicode.com/posts')
            .respond(dummyPosts);    

        endpointController = $controller("MainController", { $scope: scope });

        $httpBackend.flush();

        expect(endpointController).not.toBeNull();
        expect(scope.posts.length).toBe(1);
    }));
});

To make the example live you can use the view code below
// -- HTML Code -----------------------
<div ng-app="app" ng-controller="MainController">{{ "Hellow " + message }}
    <br/>
    <div ng-repeat="post in posts">{{ post.title }}</div>
</div>

A:

Check out $httpBackend. It lets you specify responses for specific requests.
Updates
Use angular.mock.inject to go through the usual injection process. You'll need to explicitly wire up the scope:
    var ctrl; //controller under test
    beforeEach(angular.mock.inject(function($rootScope, $controller, serviceB, serviceC) {
        scope = $rootScope.$new;
        ctrl = $controller('RatioBoxController', {
                $scope: scope,
                serviceB: serviceB,
                serviceC: serviceC,
            }
        );
    }));

You can use spies to verify methods on serviceB or serviceC were called, or the normal checks provided by $httpBackend.

